Change it so function and call explicitly expect arg: namespace.

The `var` references to arguments will need to include `arg` so it's better to be consistent.

Part of #20.

README.md

@@ -660,7 +660,7 @@ Defines a procedure that other seeds can call with `call`.
 Note that semantically it's basically equivalent to a `let-multi` with named arguments, but using `function` communicates more clearly the intent that this is a callable-sub-procedure, which allows tooling to understand it better.
 
 Required parameters:
-- `arguments` - The list of names of arguments that are expected to be passed. These variable names should not include a namespace. Internally they will be prefixed with the `arg:` namespace.
+- `arguments` - The list of names of arguments that are expected to be passed. These variable names must all be prefixed with an `arg:`
 - `block` - The sub-seed that will be evaluated where the environment will have `name=value`.
 
 #### call
@@ -670,7 +670,7 @@ Calls a procedure that was defined by `function`.
 Semantically this is just a let-multi to set parameters and then execute the function seed-reference, but it communicates intent better.
 
 Required parameters:
-- `arguments` - The object of name -> value pairs to set. These variable names should not include a namespace. Internally they will be prefixed with the `arg:` namespace.
+- `arguments` - The object of name -> value pairs to set. These variable names should all include a `arg:`
 - `function` - The sub-seed refererence to the `function` to execute.
 
 #### store

seed-schema.json

@@ -2910,7 +2910,7 @@
 									"type": "array",
 									"items": {
 										"type": "string",
-										"pattern": "^[a-zA-Z0-9-_.]*$"
+										"pattern": "^arg:[a-zA-Z0-9-_.]*$"
 									},
 									"description": "The map of name -> variables to set"
 								}
@@ -2988,7 +2988,7 @@
 										]
 									},
 									"propertyNames": {
-										"pattern": "^[a-zA-Z0-9-_.]*$"
+										"pattern": "^arg:[a-zA-Z0-9-_.]*$"
 									},
 									"description": "The map of name -> variables to set"
 								}

src/environment.ts

@@ -35,11 +35,11 @@ import {
 
 const CHANGE_ME_SENTINEL = 'CHANGE_ME';
 
-export const isNamespaced = (input : MemoryID | StoreID | VarName) : boolean => {
+const isNamespaced = (input : MemoryID | StoreID | VarName) : boolean => {
 	return input.includes(NAMESPACE_DELIMITER);
 };
 
-export const getNamespacedID = <I extends MemoryID | StoreID | VarName>(input : I, namespace : Namespace) : I => {
+const getNamespacedID = <I extends MemoryID | StoreID | VarName>(input : I, namespace : Namespace) : I => {
 	if (isNamespaced(input)) return input;
 	if (!namespaceSchema.safeParse(namespace).success) throw new Error(`${namespace} was not a valid namespace`);
 	return (namespace + NAMESPACE_DELIMITER + input) as I;

src/grow.ts

@@ -56,7 +56,8 @@ import {
 	fetchFormat,
 	SeedDataFilter,
 	SeedDataFunction,
-	SeedDataCall
+	SeedDataCall,
+	argVarName
 } from './types.js';
 
 import {
@@ -81,7 +82,7 @@ import {
 } from './template.js';
 
 import {
-	Environment, getNamespacedID, isNamespaced
+	Environment
 } from './environment.js';
 
 import {
@@ -688,18 +689,15 @@ const growLetMulti = async (seed : Seed<SeedDataLetMulti>, env : Environment) :
 	return await getProperty(seed, newEnv, data.block);
 };
 
-const FUNCTION_ARG_NAMESPACE = 'arg';
-
 const growFunction = async (seed : Seed<SeedDataFunction>, env : Environment) : Promise<Value> => {
 	const data = seed.data;
 
 	const values = await getProperty(seed, env, data.arguments);
 	if (!Array.isArray(values)) throw new Error('Values must be an array');
 	for (const name of values) {
 		if (typeof name != 'string') throw new Error('argument name must be string');
-		if (isNamespaced(name)) throw new Error('arguments should not be namespaced');
-		const processedKey = getNamespacedID(name, FUNCTION_ARG_NAMESPACE);
-		const val = env.get(processedKey);
+		if (!argVarName.safeParse(name).success) throw new Error('Arg must start with `arg:`');
+		const val = env.get(name);
 		if (val === null) throw new Error(`${val} was not set as expected`);
 	}
 	return await getProperty(seed, env, data.block);
@@ -714,9 +712,8 @@ const growCall = async (seed : Seed<SeedDataCall>, env : Environment) : Promise<
 	if (!values) throw new Error('Values must be an object');
 	const vars : EnvironmentData = {};
 	for (const [key, val] of Object.entries(values)) {
-		if (isNamespaced(key)) throw new Error('arguments should not be namespaced');
-		const processedKey = getNamespacedID(key, FUNCTION_ARG_NAMESPACE);
-		vars[processedKey] = val;
+		if (!argVarName.safeParse(key).success) throw new Error(`${key} did not start with 'arg:'`);
+		vars[key] = val;
 	}
 	const newEnv = env.clone(vars);
 	//TODO: throw if data.function is not a seed-reference to a seed of type function.

src/types.ts

@@ -59,6 +59,12 @@ const namedspacedID = z.string().regex(absoluteRegExp(namespacedIDRegExp));
 
 export type NamespacedID = z.infer<typeof namedspacedID>;
 
+const FUNCTION_ARG_NAMESPACE = 'arg';
+
+const argVarRegExp = new RegExp(FUNCTION_ARG_NAMESPACE + NAMESPACE_DELIMITER + genericIDExtraRegExp.source);
+
+export const argVarName = z.string().regex(absoluteRegExp(argVarRegExp));
+
 export const leafValue = z.union([
 	z.null(),
 	z.number(),
@@ -944,8 +950,7 @@ export type SeedDataLetMulti = z.infer<typeof seedDataLetMulti>;
 const seedDataConfigFunction = {
 	type: z.literal('function'),
 	properties: {
-		//We don't use varName because we want a non-namespaced ID
-		arguments: z.array(genericExtraID).describe('The map of name -> variables to set'),
+		arguments: z.array(argVarName).describe('The map of name -> variables to set'),
 		block: inputNonObjectValue.describe('The sub-expression where name=value will be set in environment')
 	}
 };
@@ -958,8 +963,7 @@ export type SeedDataFunction = z.infer<typeof seedDataFunction>;
 const seedDataConfigCall = {
 	type: z.literal('call'),
 	properties: {
-		//We don't use varName because we want a non-namespaced ID
-		arguments: z.record(genericExtraID, z.union([
+		arguments: z.record(argVarName, z.union([
 			lazySeedData,
 			seedReference,
 			inputValue