@haibun/core 3.0.3 → 3.1.0

package/build/steps/variables-stepper.js

@@ -1,8 +1,9 @@
+import { z } from 'zod';
 import { OK, Origin } from '../lib/defs.js';
 import { AStepper } from '../lib/astepper.js';
-import { actionNotOK, actionOK } from '../lib/util/index.js';
+import { actionOK, actionNotOK, getStepTerm, isLiteralValue } from '../lib/util/index.js';
 import { FeatureVariables } from '../lib/feature-variables.js';
-import { DOMAIN_STRING } from '../lib/domain-types.js';
+import { DOMAIN_STATEMENT, DOMAIN_STRING, normalizeDomainKey, createEnumDomainDefinition, registerDomains } from '../lib/domain-types.js';
 import { EExecutionMessageType } from '../lib/interfaces/logger.js';
 const clearVars = (vars) => () => {
     vars.getWorld().shared.clear();
@@ -10,8 +11,8 @@ const clearVars = (vars) => () => {
 };
 const cycles = (variablesStepper) => ({
     startFeature: clearVars(variablesStepper),
-    startScenario: ({ featureVars }) => {
-        variablesStepper.getWorld().shared = new FeatureVariables(variablesStepper.getWorld(), { ...featureVars.all() });
+    startScenario: ({ scopedVars }) => {
+        variablesStepper.getWorld().shared = new FeatureVariables(variablesStepper.getWorld(), { ...scopedVars.all() });
         return Promise.resolve();
     },
 });
@@ -23,65 +24,107 @@ class VariablesStepper extends AStepper {
         this.steppers = steppers;
         await Promise.resolve();
     }
-    checkIsSet(what) {
-        return this.getVarValue(what) !== undefined;
-    }
-    // FIXME provide explicit mapping to more carefully handle env, etc.
-    getVarValue(what) {
-        const envVal = this.getWorld().options.envVariables[what];
-        if (envVal !== undefined) {
-            return envVal;
-        }
-        return this.getWorld().shared.get(what);
-    }
-    isSet(what) {
-        if (this.checkIsSet(what)) {
-            return OK;
-        }
-        return actionNotOK(`${what} not set`);
-    }
     steps = {
-        combineAs: {
-            gwta: 'combine {p1} and {p2} as {domain} to {what}',
-            precludes: [`${VariablesStepper.name}.combine`],
-            action: ({ p1, p2, domain }, featureStep) => {
+        defineOpenSet: {
+            gwta: `set of {domain: string} as {superdomains: ${DOMAIN_STATEMENT}}`,
+            handlesUndefined: ['domain'],
+            action: ({ domain, superdomains }, featureStep) => this.registerSubdomainFromStatement(domain, superdomains, featureStep)
+        },
+        defineOrderedSet: {
+            precludes: [`${VariablesStepper.name}.defineValuesSet`, `${VariablesStepper.name}.defineSet`],
+            handlesUndefined: ['domain'],
+            gwta: `ordered set of {domain: string} is {values:${DOMAIN_STATEMENT}}`,
+            action: ({ domain, values }, featureStep) => this.registerValuesDomainFromStatement(domain, values, featureStep, { ordered: true, label: 'ordered set' })
+        },
+        defineValuesSet: {
+            gwta: `set of {domain: string} is {values:${DOMAIN_STATEMENT}}`,
+            handlesUndefined: ['domain'],
+            action: ({ domain, values }, featureStep) => this.registerValuesDomainFromStatement(domain, values, featureStep, { ordered: false, label: 'set' })
+        },
+        statementSetValues: {
+            expose: false,
+            gwta: '\\[{items: string}\\]',
+            action: () => OK,
+        },
+        composeAs: {
+            gwta: 'compose {what} as {domain} with {template}',
+            handlesUndefined: ['what', 'template'],
+            precludes: [`${VariablesStepper.name}.compose`],
+            action: ({ domain }, featureStep) => {
                 const { term } = featureStep.action.stepValuesMap.what;
-                this.getWorld().shared.set({ term: String(term), value: `${p1}${p2}`, domain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
-                return Promise.resolve(OK);
+                const templateVal = featureStep.action.stepValuesMap.template;
+                if (!templateVal?.term)
+                    return actionNotOK('template not provided');
+                const result = this.interpolateTemplate(templateVal.term, featureStep);
+                if (result.error)
+                    return actionNotOK(result.error);
+                return trySetVariable(this.getWorld().shared, { term: String(term), value: result.value, domain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
             }
         },
-        combine: {
-            gwta: 'combine {p1} and {p2} to {what}',
-            action: ({ p1, p2 }, featureStep) => {
+        compose: {
+            gwta: 'compose {what} with {template}',
+            handlesUndefined: ['what', 'template'],
+            action: (_, featureStep) => {
                 const { term } = featureStep.action.stepValuesMap.what;
-                this.getWorld().shared.set({ term: String(term), value: `${p1}${p2}`, domain: DOMAIN_STRING, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
-                return Promise.resolve(OK);
+                const templateVal = featureStep.action.stepValuesMap.template;
+                if (!templateVal?.term)
+                    return actionNotOK('template not provided');
+                const result = this.interpolateTemplate(templateVal.term, featureStep);
+                if (result.error)
+                    return actionNotOK(result.error);
+                return trySetVariable(this.getWorld().shared, { term: String(term), value: result.value, domain: DOMAIN_STRING, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
             }
         },
         increment: {
             gwta: 'increment {what}',
-            action: ({ what }, featureStep) => {
-                void what; // used for type checking
-                const { term, domain } = featureStep.action.stepValuesMap.what;
-                const presentVal = this.getVarValue(term);
-                let newVal;
+            handlesUndefined: ['what'],
+            action: (_, featureStep) => {
+                const { term: rawTerm, domain } = featureStep.action.stepValuesMap.what;
+                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                if (interpolated.error)
+                    return actionNotOK(interpolated.error);
+                const term = interpolated.value;
+                const resolved = this.getWorld().shared.resolveVariable({ term, origin: Origin.var, domain }, featureStep);
+                const presentVal = resolved.value;
+                const effectiveDomain = resolved.domain;
                 if (presentVal === undefined) {
-                    newVal = 0;
+                    return actionNotOK(`${term} not set`);
                 }
-                else {
-                    const numVal = Number(presentVal);
-                    if (isNaN(numVal)) {
-                        return actionNotOK(`cannot increment non-numeric variable ${term} with value "${presentVal}"`);
+                // If domain is an ordered enum, advance to the next enum value
+                const domainKey = effectiveDomain ? normalizeDomainKey(effectiveDomain) : undefined;
+                const registered = domainKey ? this.getWorld().domains[domainKey] : undefined;
+                if (registered?.comparator && Array.isArray(registered.values) && registered.values.length) {
+                    const enumValues = registered.values;
+                    const idx = enumValues.indexOf(String(presentVal));
+                    if (idx === -1) {
+                        return actionNotOK(`${term} has value "${presentVal}" which is not in domain values`);
+                    }
+                    const nextIdx = Math.min(enumValues.length - 1, idx + 1);
+                    const nextVal = enumValues[nextIdx];
+                    if (nextVal === presentVal) {
+                        return OK;
                     }
-                    newVal = numVal + 1;
+                    this.getWorld().shared.set({ term: String(term), value: nextVal, domain: effectiveDomain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
+                    return OK;
+                }
+                // Fallback: numeric increment
+                const numVal = Number(presentVal);
+                if (isNaN(numVal)) {
+                    return actionNotOK(`cannot increment non-numeric variable ${term} with value "${presentVal}"`);
                 }
-                this.getWorld().shared.set({ term: String(term), value: newVal, domain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
-                const messageContext = {
+                const newNum = numVal + 1;
+                this.getWorld().shared.set({ term: String(term), value: String(newNum), domain: effectiveDomain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
+                this.getWorld().logger.info(`incremented ${term} to ${newNum}`, {
                     incident: EExecutionMessageType.ACTION,
-                    incidentDetails: { json: { incremented: { [term]: newVal } } },
-                };
-                this.getWorld().logger.info(`incremented ${term} to ${newVal}`, messageContext);
-                return Promise.resolve(OK);
+                    incidentDetails: { json: { incremented: { [term]: newNum } } },
+                });
+                this.getWorld().eventLogger.log(featureStep, 'info', `incremented ${term} to ${newNum}`, {
+                    variable: term,
+                    oldValue: presentVal,
+                    newValue: newNum,
+                    operation: 'increment'
+                });
+                return OK;
             }
         },
         showEnv: {
@@ -96,91 +139,417 @@ class VariablesStepper extends AStepper {
         showVars: {
             gwta: 'show vars',
             action: () => {
-                console.info('vars', this.getWorld().shared.all());
-                return Promise.resolve(actionOK({ artifact: { artifactType: 'json', json: { vars: this.getWorld().shared.all() } } }));
+                const displayVars = Object.fromEntries(Object.entries(this.getWorld().shared.all()).map(([k, v]) => [k, v.value]));
+                console.info('vars', displayVars);
+                return actionOK({ artifact: { artifactType: 'json', json: { vars: displayVars } } });
             },
         },
         set: {
             gwta: 'set( empty)? {what: string} to {value: string}',
+            handlesUndefined: ['what', 'value'],
             precludes: ['Haibun.prose'],
             action: (args, featureStep) => {
-                const emptyOnly = !!featureStep.in.match(/set empty /);
-                const { term, domain, origin } = featureStep.action.stepValuesMap.what;
-                if (emptyOnly && this.getWorld().shared.get(term) !== undefined) {
-                    return OK;
+                const { term: rawTerm, domain, origin } = featureStep.action.stepValuesMap.what;
+                const parsedValue = this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep);
+                if (parsedValue.value === undefined)
+                    return actionNotOK(`Variable ${featureStep.action.stepValuesMap.value.term} not found`);
+                const resolved = { value: String(parsedValue.value) };
+                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                if (interpolated.error)
+                    return actionNotOK(interpolated.error);
+                const term = interpolated.value;
+                const skip = shouldSkipEmpty(featureStep, term, this.getWorld().shared);
+                if (skip)
+                    return skip;
+                // Inherit domain from existing variable if not explicitly specified
+                const existing = this.getWorld().shared.resolveVariable({ term, origin: Origin.var }, featureStep);
+                const effectiveDomain = (domain === DOMAIN_STRING && existing?.domain) ? existing.domain : (domain || DOMAIN_STRING);
+                const result = trySetVariable(this.getWorld().shared, { term, value: resolved.value, domain: effectiveDomain, origin }, provenanceFromFeatureStep(featureStep));
+                if (result.ok) {
+                    this.getWorld().eventLogger.log(featureStep, 'info', `set ${term} to ${resolved.value}`, {
+                        variable: term,
+                        newValue: resolved.value,
+                        domain: effectiveDomain,
+                        operation: 'set'
+                    });
                 }
-                this.getWorld().shared.set({ term: String(term), value: args.value, domain, origin }, provenanceFromFeatureStep(featureStep));
-                return Promise.resolve(OK);
+                return result;
             }
         },
         setAs: {
-            gwta: 'set( empty)? {what: string} as {domain: string} to {value: string}',
+            gwta: 'set( empty)? {what} as {domain} to {value}',
+            handlesUndefined: ['what', 'domain', 'value'],
             precludes: [`${VariablesStepper.name}.set`],
             action: ({ value, domain }, featureStep) => {
-                const emptyOnly = !!featureStep.in.match(/set empty /);
-                const { term, origin } = featureStep.action.stepValuesMap.what;
-                if (emptyOnly && this.getWorld().shared.get(term) !== undefined) {
-                    return OK;
+                const readonly = !!featureStep.in.match(/ as read-only /);
+                const { term: rawTerm, origin } = featureStep.action.stepValuesMap.what;
+                const parsedValue = this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep);
+                if (parsedValue.value === undefined)
+                    return actionNotOK(`Variable ${featureStep.action.stepValuesMap.value.term} not found`);
+                const resolved = { value: String(parsedValue.value) };
+                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                if (interpolated.error)
+                    return actionNotOK(interpolated.error);
+                const term = interpolated.value;
+                const skip = shouldSkipEmpty(featureStep, term, this.getWorld().shared);
+                if (skip)
+                    return skip;
+                // Fallback for unquoted domain names (e.g. 'as number') that resolve to undefined
+                let effectiveDomain = domain ?? getStepTerm(featureStep, 'domain');
+                if (effectiveDomain) {
+                    if (effectiveDomain.startsWith('read-only ')) {
+                        effectiveDomain = effectiveDomain.replace('read-only ', '');
+                    }
+                    if (effectiveDomain.startsWith('"') && effectiveDomain.endsWith('"')) {
+                        effectiveDomain = effectiveDomain.slice(1, -1);
+                    }
+                }
+                let finalValue = resolved.value;
+                if (typeof finalValue === 'string' && finalValue.startsWith('"') && finalValue.endsWith('"')) {
+                    finalValue = finalValue.slice(1, -1);
                 }
-                this.getWorld().shared.set({ term: String(term), value: value, domain, origin }, provenanceFromFeatureStep(featureStep));
+                return trySetVariable(this.getWorld().shared, { term, value: finalValue, domain: effectiveDomain, origin, readonly }, provenanceFromFeatureStep(featureStep));
+            }
+        },
+        unset: {
+            gwta: 'unset {what: string}',
+            action: ({ what }, featureStep) => {
+                const { term } = featureStep.action.stepValuesMap.what;
+                this.getWorld().shared.unset(term);
                 return Promise.resolve(OK);
             }
         },
         setRandom: {
             precludes: [`${VariablesStepper.name}.set`],
             gwta: `set( empty)? {what: string} to {length: number} random characters`,
+            handlesUndefined: ['what'],
             action: ({ length }, featureStep) => {
-                const emptyOnly = !!featureStep.in.match(/set empty /);
                 const { term } = featureStep.action.stepValuesMap.what;
                 if (length < 1 || length > 100) {
                     return actionNotOK(`length ${length} must be between 1 and 100`);
                 }
-                if (emptyOnly && this.getWorld().shared.get(term) !== undefined) {
-                    return OK;
-                }
+                const skip = shouldSkipEmpty(featureStep, term, this.getWorld().shared);
+                if (skip)
+                    return skip;
                 let rand = '';
                 while (rand.length < length) {
                     rand += Math.random().toString(36).substring(2, 2 + length);
                 }
                 rand = rand.substring(0, length);
-                this.getWorld().shared.set({ term: String(term), value: rand, domain: DOMAIN_STRING, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
-                return Promise.resolve(OK);
+                return trySetVariable(this.getWorld().shared, { term, value: rand, domain: DOMAIN_STRING, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
             }
         },
         is: {
             gwta: 'variable {what} is {value}',
+            handlesUndefined: ['what', 'value'],
+            action: (args, featureStep) => {
+                const { term: rawTerm } = featureStep.action.stepValuesMap.what;
+                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                if (interpolated.error)
+                    return actionNotOK(interpolated.error);
+                const term = interpolated.value;
+                const resolved = this.getWorld().shared.resolveVariable({ term, origin: Origin.defined }, featureStep);
+                if (resolved.value === undefined) {
+                    return actionNotOK(`${term} is not set`);
+                }
+                const storedVal = resolved.value;
+                const parsedValue = this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep);
+                if (parsedValue.value === undefined)
+                    return actionNotOK(`Variable ${featureStep.action.stepValuesMap.value.term} not found`);
+                const value = String(parsedValue.value);
+                const domainKey = normalizeDomainKey(resolved.domain);
+                const compareVal = this.getWorld().domains[domainKey].coerce({ term: '_cmp', value, domain: domainKey, origin: Origin.quoted }, featureStep, this.steppers);
+                return JSON.stringify(storedVal) === JSON.stringify(compareVal) ? OK : actionNotOK(`${term} is ${JSON.stringify(storedVal)}, not ${JSON.stringify(compareVal)}`);
+            }
+        },
+        isLessThan: {
+            gwta: 'variable {what} is less than {value}',
+            handlesUndefined: ['what', 'value'],
+            precludes: ['VariablesStepper.is'],
             action: ({ what, value }, featureStep) => {
-                void what; // used for type checking
-                const { term, domain } = featureStep.action.stepValuesMap.what;
-                const val = this.getVarValue(term);
-                const asDomain = this.getWorld().domains[domain].coerce({ domain, value, term, origin: 'quoted' });
-                return JSON.stringify(val) === JSON.stringify(asDomain) ? OK : actionNotOK(`${term} is ${JSON.stringify(val)}, not ${JSON.stringify(value)}`);
+                const term = getStepTerm(featureStep, 'what') ?? what;
+                return this.compareValues(featureStep, term, value, '<');
             }
         },
-        isSet: {
+        isMoreThan: {
+            gwta: 'variable {what} is more than {value}',
+            handlesUndefined: ['what', 'value'],
             precludes: ['VariablesStepper.is'],
-            gwta: 'variable {what: string} is set',
+            action: ({ what, value }, featureStep) => {
+                const term = getStepTerm(featureStep, 'what') ?? what;
+                return this.compareValues(featureStep, term, value, '>');
+            }
+        },
+        exists: {
+            gwta: 'variable {what} exists',
+            handlesUndefined: ['what'],
             action: ({ what }, featureStep) => {
-                // Use term from stepValuesMap when available (normal execution), fall back to what for kireji
-                const term = featureStep?.action?.stepValuesMap?.what?.term ?? what;
-                return this.isSet(term);
+                const term = (getStepTerm(featureStep, 'what') ?? what);
+                const resolved = this.getWorld().shared.resolveVariable({ term, origin: Origin.defined }, featureStep);
+                return resolved && (resolved.origin === Origin.var || resolved.origin === Origin.env) ? OK : actionNotOK(`${what} not set`);
             }
         },
         showVar: {
             gwta: 'show var {what}',
-            action: (args, featureStep) => {
-                const { term } = featureStep.action.stepValuesMap.what;
-                const stepValue = this.getWorld().shared.all()[term];
-                if (!stepValue) {
+            handlesUndefined: ['what'],
+            action: (_, featureStep) => {
+                const rawTerm = getStepTerm(featureStep, 'what');
+                if (rawTerm === undefined)
+                    return actionNotOK('variable not provided');
+                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                if (interpolated.error)
+                    return actionNotOK(interpolated.error);
+                const term = interpolated.value;
+                const stepValue = this.getWorld().shared.resolveVariable({ term, origin: Origin.defined }, featureStep);
+                if (stepValue.value === undefined) {
                     this.getWorld().logger.info(`is undefined`);
                 }
                 else {
-                    this.getWorld().logger.info(`is ${JSON.stringify({ ...stepValue, provenance: stepValue.provenance.map((p, i) => ({ [i]: { in: p.in, seq: p.seq.join(','), when: p.when } })) }, null, 2)}`);
+                    const provenance = featureStep.action.stepValuesMap.what.provenance?.map((p, i) => ({ [i]: { in: p.in, seq: p.seq.join(','), when: p.when } }));
+                    this.getWorld().logger.info(`is ${JSON.stringify({ ...stepValue, provenance }, null, 2)}`);
                 }
                 return actionOK({ artifact: { artifactType: 'json', json: { json: stepValue } } });
             }
         },
+        showDomains: {
+            gwta: 'show domains',
+            action: () => {
+                const domains = this.getWorld().domains;
+                const allVars = this.getWorld().shared.all();
+                const summary = {};
+                for (const [name, def] of Object.entries(domains)) {
+                    // Count variables in this domain
+                    let members = 0;
+                    for (const variable of Object.values(allVars)) {
+                        if (variable.domain && normalizeDomainKey(variable.domain) === name) {
+                            members++;
+                        }
+                    }
+                    // Determine type from schema or values
+                    let type = 'schema';
+                    if (def.values) {
+                        type = def.values;
+                    }
+                    else if (def.description) {
+                        type = def.description;
+                    }
+                    summary[name] = {
+                        type,
+                        members,
+                        ordered: !!def.comparator
+                    };
+                }
+                this.getWorld().logger.info(`Domains: ${JSON.stringify(summary, null, 2)}`);
+                return OK;
+            }
+        },
+        showDomain: {
+            gwta: 'show domain {name}',
+            handlesUndefined: ['name'],
+            action: (_, featureStep) => {
+                const name = getStepTerm(featureStep, 'name');
+                const domain = this.getWorld().domains[name];
+                if (!domain) {
+                    return actionNotOK(`Domain "${name}" not found`);
+                }
+                const allVars = this.getWorld().shared.all();
+                const members = {};
+                for (const [key, variable] of Object.entries(allVars)) {
+                    if (variable.domain && normalizeDomainKey(variable.domain) === name) {
+                        members[key] = variable.value;
+                    }
+                }
+                this.getWorld().logger.info(`Domain "${name}": ${JSON.stringify({ ...domain, members }, null, 2)}`);
+                return OK;
+            }
+        },
+        // Membership check: value is in domain (enum or member values)
+        // Handles quoted ("value"), braced ({var}), or bare (value) forms
+        // fallback: true lets quantifiers take precedence when both match
+        isIn: {
+            match: /^(.+) is in ([a-zA-Z][a-zA-Z0-9 ]*)$/,
+            fallback: true,
+            action: (_, featureStep) => {
+                const matchResult = featureStep.in.match(/^(.+) is in ([a-zA-Z][a-zA-Z0-9 ]*)$/);
+                if (!matchResult) {
+                    return actionNotOK('Invalid "is in" syntax');
+                }
+                let valueTerm = matchResult[1].trim();
+                // Strip quotes if present
+                if ((valueTerm.startsWith('"') && valueTerm.endsWith('"')) ||
+                    (valueTerm.startsWith('`') && valueTerm.endsWith('`'))) {
+                    valueTerm = valueTerm.slice(1, -1);
+                }
+                // Strip braces if present and resolve variable
+                if (valueTerm.startsWith('{') && valueTerm.endsWith('}')) {
+                    valueTerm = valueTerm.slice(1, -1);
+                }
+                // Try to resolve as variable, fall back to literal
+                const resolved = this.getWorld().shared.resolveVariable({ term: valueTerm, origin: Origin.defined });
+                const actualValue = resolved?.value !== undefined ? String(resolved.value) : valueTerm;
+                const domainName = matchResult[2].trim();
+                const domainKey = normalizeDomainKey(domainName);
+                const domainDef = this.getWorld().domains[domainKey];
+                if (!domainDef) {
+                    return actionNotOK(`Domain "${domainName}" is not defined`);
+                }
+                // Check enum values first
+                if (Array.isArray(domainDef.values) && domainDef.values.includes(actualValue)) {
+                    return OK;
+                }
+                // Check member values
+                const allVars = this.getWorld().shared.all();
+                const memberValues = Object.values(allVars)
+                    .filter(v => v.domain && normalizeDomainKey(v.domain) === domainKey)
+                    .map(v => String(v.value));
+                return memberValues.includes(actualValue)
+                    ? OK
+                    : actionNotOK(`"${actualValue}" is not in ${domainName}`);
+            }
+        },
+        // Starts with: predicate for prefix checking
+        // Starts with literal 'that' for unambiguous parsing in compositions
+        // Usage: that {page} starts with {prefix}
+        startsWith: {
+            gwta: 'that {value} starts with {prefix}',
+            action: ({ value, prefix }) => {
+                const actualValue = String(value);
+                const actualPrefix = String(prefix);
+                return actualValue.startsWith(actualPrefix)
+                    ? OK
+                    : actionNotOK(`"${actualValue}" does not start with "${actualPrefix}"`);
+            }
+        },
     };
+    compareValues(featureStep, rawTerm, value, operator) {
+        const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+        if (interpolated.error)
+            return actionNotOK(interpolated.error);
+        const term = interpolated.value;
+        const stored = this.getWorld().shared.resolveVariable({ term, origin: Origin.var }, featureStep);
+        if (!stored) {
+            return actionNotOK(`${term} is not set`);
+        }
+        const domainKey = normalizeDomainKey(stored.domain);
+        const domainEntry = this.getWorld().domains[domainKey];
+        if (!domainEntry) {
+            throw new Error(`No domain coercer found for domain "${domainKey}"`);
+        }
+        const left = domainEntry.coerce({ ...stored, domain: domainKey }, featureStep, this.steppers);
+        let rightValue = value;
+        if (rightValue === undefined) {
+            const parsed = this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep);
+            if (parsed.value === undefined)
+                return actionNotOK(`Variable ${featureStep.action.stepValuesMap.value.term} not found`);
+            rightValue = String(parsed.value);
+        }
+        if (typeof rightValue === 'string' && rightValue.startsWith('"') && rightValue.endsWith('"')) {
+            rightValue = rightValue.slice(1, -1);
+        }
+        const right = domainEntry.coerce({ term: `${term}__comparison`, value: rightValue, domain: domainKey, origin: Origin.quoted }, featureStep, this.steppers);
+        const comparison = compareDomainValues(domainEntry, left, right, stored.domain);
+        if (operator === '>') {
+            return comparison > 0 ? OK : actionNotOK(`${term} is ${JSON.stringify(left)}, not ${JSON.stringify(right)}`);
+        }
+        if (operator === '<') {
+            return comparison < 0 ? OK : actionNotOK(`${term} is ${JSON.stringify(left)}, not ${JSON.stringify(right)}`);
+        }
+        return actionNotOK(`Unsupported operator: ${operator}`);
+    }
+    /**
+     * Interpolates a template string by replacing {varName} placeholders with variable values.
+     * Returns the interpolated string or an error if a variable is not found.
+     */
+    interpolateTemplate(template, featureStep) {
+        const placeholderRegex = /\{([^}]+)\}/g;
+        let result = template;
+        let match;
+        while ((match = placeholderRegex.exec(template)) !== null) {
+            const varName = match[1];
+            // Origin.defined checks runtimeArgs -> env -> literal fallback?
+            // We want strict. If resolves to literal, that's fine if user quoted it?
+            // But {unknown} resolves to undefined if not found?
+            // In feature-variables.ts, resolveVariable defaults to input.term if isLiteralValue.
+            // {unknown} is NOT literal value (braces).
+            // So resolveVariable returns undefined.
+            const resolved = this.getWorld().shared.resolveVariable({ term: varName, origin: Origin.defined }, featureStep);
+            if (resolved.value === undefined) {
+                return { error: `Variable ${varName} not found` };
+            }
+            result = result.replace(match[0], String(resolved.value));
+        }
+        return { value: result };
+    }
+    registerSubdomainFromStatement(domain, superdomains, featureStep) {
+        try {
+            const fallback = getStepTerm(featureStep, 'superdomains') ?? featureStep.in;
+            const superdomainNames = extractValuesFromFragments(superdomains, fallback);
+            if (!superdomainNames.length) {
+                throw new Error('Superdomain set must specify at least one superdomain');
+            }
+            const uniqueNames = Array.from(new Set(superdomainNames));
+            const effectiveDomain = domain ?? getStepTerm(featureStep, 'domain');
+            if (!effectiveDomain)
+                return actionNotOK('Domain name must be provided');
+            const domainKey = normalizeDomainKey(effectiveDomain);
+            if (this.getWorld().domains[domainKey]) {
+                return actionNotOK(`Domain "${domainKey}" already exists`);
+            }
+            const superdomainDefs = uniqueNames.map((name) => {
+                const normalized = normalizeDomainKey(name);
+                const registered = this.getWorld().domains[normalized];
+                if (!registered) {
+                    throw new Error(`Superdomain "${name}" not registered`);
+                }
+                return registered;
+            });
+            const enumSources = superdomainDefs.filter((entry) => Array.isArray(entry.values) && entry.values.length);
+            const uniqueValues = Array.from(new Set(enumSources.flatMap((entry) => entry.values)));
+            const description = `Values inherited from ${uniqueNames.join(', ')}`;
+            if (enumSources.length === superdomainDefs.length && uniqueValues.length) {
+                const definition = createEnumDomainDefinition({ name: domainKey, values: uniqueValues, description });
+                registerDomains(this.getWorld(), [[definition]]);
+                return OK;
+            }
+            const schemaList = superdomainDefs.map((entry) => entry.schema);
+            if (!schemaList.length) {
+                throw new Error('Superdomains did not expose any schema to derive from');
+            }
+            let mergedSchema = schemaList[0];
+            for (let i = 1; i < schemaList.length; i++) {
+                mergedSchema = z.union([mergedSchema, schemaList[i]]);
+            }
+            const definition = {
+                selectors: [domainKey],
+                schema: mergedSchema,
+                coerce: (proto) => mergedSchema.parse(proto.value),
+                description,
+            };
+            registerDomains(this.getWorld(), [[definition]]);
+            return OK;
+        }
+        catch (error) {
+            return actionNotOK(error instanceof Error ? error.message : String(error));
+        }
+    }
+    registerValuesDomainFromStatement(domain, valueFragments, featureStep, options) {
+        try {
+            const values = extractValuesFromFragments(valueFragments, getStepTerm(featureStep, 'values') ?? featureStep.in);
+            const effectiveDomain = domain ?? getStepTerm(featureStep, 'domain');
+            if (!effectiveDomain)
+                return actionNotOK('Domain name must be provided');
+            const domainKey = normalizeDomainKey(effectiveDomain);
+            if (this.getWorld().domains[domainKey]) {
+                return actionNotOK(`Domain "${domainKey}" already exists`);
+            }
+            const definition = createEnumDomainDefinition({ name: domainKey, values, description: options?.description, ordered: options?.ordered });
+            registerDomains(this.getWorld(), [[definition]]);
+            return OK;
+        }
+        catch (error) {
+            return actionNotOK(error instanceof Error ? error.message : String(error));
+        }
+    }
 }
 export default VariablesStepper;
 export const didNotOverwrite = (what, present, value) => ({
@@ -193,4 +562,85 @@ export function provenanceFromFeatureStep(featureStep) {
         when: `${featureStep.action.stepperName}.steps.${featureStep.action.actionName}`
     };
 }
+const QUOTED_STRING = /"([^"]+)"/g;
+const extractValuesFromFragments = (valueFragments, fallback) => {
+    if (valueFragments?.length) {
+        const innerChunks = valueFragments.map(fragment => {
+            const raw = fragment.in ?? fragment.action?.stepValuesMap?.items?.term ?? '';
+            const trimmed = raw.trim();
+            if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                return trimmed.slice(1, -1).trim();
+            }
+            return trimmed;
+        }).filter(Boolean);
+        const inner = innerChunks.join(' ').trim();
+        if (!inner) {
+            throw new Error('Set values cannot be empty');
+        }
+        return parseQuotedOrWordList(inner);
+    }
+    if (fallback) {
+        return parseBracketedValues(fallback);
+    }
+    throw new Error('Set statement missing values');
+};
+const parseBracketedValues = (raw) => {
+    const trimmed = raw.trim();
+    const start = trimmed.indexOf('[');
+    const end = trimmed.lastIndexOf(']');
+    if (start === -1 || end === -1 || end <= start) {
+        throw new Error('Set values must include [ ]');
+    }
+    const inner = trimmed.substring(start + 1, end).trim();
+    return parseQuotedOrWordList(inner);
+};
+const parseQuotedOrWordList = (value) => {
+    const quoted = [...value.matchAll(QUOTED_STRING)].map(match => match[1].trim()).filter(Boolean);
+    if (quoted.length) {
+        return quoted;
+    }
+    return value.split(/[\s,]+/).map(token => token.trim()).filter(Boolean);
+};
+const compareDomainValues = (domain, left, right, domainName) => {
+    if (domain.comparator) {
+        return domain.comparator(left, right);
+    }
+    if (typeof left === 'number' && typeof right === 'number') {
+        return left - right;
+    }
+    if (left instanceof Date && right instanceof Date) {
+        return left.getTime() - right.getTime();
+    }
+    throw new Error(`Domain ${domainName} does not support magnitude comparison`);
+};
+const renderComparable = (value) => {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    return JSON.stringify(value);
+};
+// ======== Helpers ========
+// Resolves undefined value to literal if it looks like a string
+function resolveValueOrLiteral(valMap, value) {
+    if (valMap && valMap.origin === Origin.defined && value === undefined) {
+        return isLiteralValue(valMap.term)
+            ? { value: String(valMap.term) }
+            : { value: undefined, error: `Variable ${valMap.term} is not defined` };
+    }
+    return { value };
+}
+// Returns OK if "set empty" and variable exists
+function shouldSkipEmpty(featureStep, term, shared) {
+    return (featureStep.in.includes('set empty ') && shared.get(term) !== undefined) ? OK : undefined;
+}
+// Wraps shared.set in try/catch
+function trySetVariable(shared, opts, provenance) {
+    try {
+        shared.set({ term: String(opts.term), value: opts.value, domain: opts.domain, origin: opts.origin, readonly: opts.readonly }, provenance);
+        return OK;
+    }
+    catch (e) {
+        return actionNotOK(e.message);
+    }
+}
 //# sourceMappingURL=variables-stepper.js.map