@haibun/core 4.0.0-alpha.1 → 4.0.0-alpha.3

package/build/steps/variables-stepper.js

@@ -1,91 +1,105 @@
-import { z } from 'zod';
-import { OK, Origin } from '../schema/protocol.js';
-import { AStepper } from '../lib/astepper.js';
-import { actionOK, actionNotOK, getStepTerm } from '../lib/util/index.js';
-import { FeatureVariables, OBSCURED_VALUE } from '../lib/feature-variables.js';
-import { sanitizeObjectSecrets } from '../lib/util/secret-utils.js';
-import { DOMAIN_STATEMENT, DOMAIN_STRING, normalizeDomainKey, createEnumDomainDefinition, registerDomains } from '../lib/domain-types.js';
-const clearVars = (vars) => () => {
-    vars.getWorld().shared.clear();
-    return;
+import { z } from "zod";
+import { OK, Origin } from "../schema/protocol.js";
+import { AStepper } from "../lib/astepper.js";
+import { actionOK, actionNotOK, actionOKWithProducts, getStepTerm } from "../lib/util/index.js";
+import { FlowRunner } from "../lib/core/flow-runner.js";
+import { FeatureVariables, OBSCURED_VALUE } from "../lib/feature-variables.js";
+import { sanitizeObjectSecrets } from "../lib/util/secret-utils.js";
+import { DOMAIN_STATEMENT, DOMAIN_STRING, normalizeDomainKey, createEnumDomainDefinition, registerDomains, } from "../lib/domains.js";
+const clearVars = (vars) => async () => {
+    await vars.getWorld().shared.getStore().clear();
 };
 const cycles = (variablesStepper) => ({
     startFeature: clearVars(variablesStepper),
-    startScenario: ({ scopedVars }) => {
-        variablesStepper.getWorld().shared = new FeatureVariables(variablesStepper.getWorld(), { ...scopedVars.all() });
-        return Promise.resolve();
+    startScenario: async ({ scopedVars }) => {
+        variablesStepper.getWorld().shared = new FeatureVariables(variablesStepper.getWorld(), { ...(await scopedVars.all()) });
     },
 });
 class VariablesStepper extends AStepper {
-    description = 'Set, get, and compare variables; define domains and check membership';
+    description = "Set, get, and compare variables; define domains and check membership";
     cycles = cycles(this);
     steppers;
+    runner;
     async setWorld(world, steppers) {
         this.world = world;
         this.steppers = steppers;
+        this.runner = new FlowRunner(world, steppers);
         await Promise.resolve();
     }
     steps = {
         defineOpenSet: {
             gwta: `set of {domain: string} as {superdomains: ${DOMAIN_STATEMENT}}`,
-            handlesUndefined: ['domain'],
-            action: ({ domain, superdomains }, featureStep) => this.registerSubdomainFromStatement(domain, superdomains, featureStep)
+            handlesUndefined: ["domain"],
+            action: ({ domain, superdomains }, featureStep) => this.registerSubdomainFromStatement(domain, superdomains, featureStep),
         },
         defineOrderedSet: {
             precludes: [`${VariablesStepper.name}.defineValuesSet`, `${VariablesStepper.name}.defineSet`],
-            handlesUndefined: ['domain'],
+            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' })
+            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' })
+            handlesUndefined: ["domain"],
+            action: ({ domain, values }, featureStep) => this.registerValuesDomainFromStatement(domain, values, featureStep, { ordered: false, label: "set" }),
         },
         statementSetValues: {
-            expose: false,
-            gwta: '\\[{items: string}\\]',
+            exposeMCP: false,
+            gwta: "\\[{items: string}\\]",
             action: () => OK,
         },
         composeAs: {
-            gwta: 'compose {what} as {domain} with {template}',
-            handlesUndefined: ['what', 'template'],
+            gwta: "compose {what} as {domain} with {template}",
+            handlesUndefined: ["what", "template"],
             precludes: [`${VariablesStepper.name}.compose`],
-            action: ({ domain }, featureStep) => {
+            action: async ({ domain }, featureStep) => {
                 const { term } = featureStep.action.stepValuesMap.what;
                 const templateVal = featureStep.action.stepValuesMap.template;
                 if (!templateVal?.term)
-                    return actionNotOK('template not provided');
-                const result = this.interpolateTemplate(templateVal.term, featureStep);
+                    return actionNotOK("template not provided");
+                const result = await 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, secret: result.secret }, provenanceFromFeatureStep(featureStep));
-            }
+            },
         },
         compose: {
-            gwta: 'compose {what} with {template}',
-            handlesUndefined: ['what', 'template'],
-            action: (_, featureStep) => {
+            gwta: "compose {what} with {template}",
+            handlesUndefined: ["what", "template"],
+            action: async (_, featureStep) => {
                 const { term } = featureStep.action.stepValuesMap.what;
                 const templateVal = featureStep.action.stepValuesMap.template;
                 if (!templateVal?.term)
-                    return actionNotOK('template not provided');
-                const result = this.interpolateTemplate(templateVal.term, featureStep);
+                    return actionNotOK("template not provided");
+                const result = await 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, secret: result.secret }, provenanceFromFeatureStep(featureStep));
             },
         },
+        setFromStatement: {
+            gwta: `set {what: string} from {statement: ${DOMAIN_STATEMENT}}`,
+            handlesUndefined: ["what"],
+            precludes: [`${VariablesStepper.name}.set`],
+            action: async ({ statement }, featureStep) => {
+                const { term } = featureStep.action.stepValuesMap.what;
+                const result = await this.runner.runSteps(statement, { intent: { mode: "authoritative" }, parentStep: featureStep });
+                if (!result.ok)
+                    return actionNotOK(`set from statement failed: ${result.errorMessage}`);
+                await this.getWorld().shared.setJSON(String(term), result.products ?? {}, Origin.var, featureStep);
+                return actionOK();
+            },
+        },
         increment: {
-            gwta: 'increment {what}',
-            handlesUndefined: ['what'],
-            action: (_, featureStep) => {
+            gwta: "increment {what}",
+            handlesUndefined: ["what"],
+            action: async (_, featureStep) => {
                 const { term: rawTerm } = featureStep.action.stepValuesMap.what;
-                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                const interpolated = await 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 }, featureStep);
+                const resolved = await this.getWorld().shared.resolveVariable({ term, origin: Origin.var }, featureStep);
                 const presentVal = resolved.value;
                 const effectiveDomain = resolved.domain;
                 if (presentVal === undefined) {
@@ -105,7 +119,7 @@ class VariablesStepper extends AStepper {
                     if (nextVal === presentVal) {
                         return OK;
                     }
-                    this.getWorld().shared.set({ term: String(term), value: nextVal, domain: effectiveDomain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
+                    await this.getWorld().shared.set({ term: String(term), value: nextVal, domain: effectiveDomain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
                     return OK;
                 }
                 // Fallback: numeric increment
@@ -114,252 +128,267 @@ class VariablesStepper extends AStepper {
                     return actionNotOK(`cannot increment non-numeric variable ${term} with value "${presentVal}"`);
                 }
                 const newNum = numVal + 1;
-                this.getWorld().shared.set({ term: String(term), value: String(newNum), domain: effectiveDomain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
-                this.getWorld().eventLogger.log(featureStep, 'info', `incremented ${term} to ${newNum}`, {
+                await this.getWorld().shared.set({ term: String(term), value: String(newNum), domain: effectiveDomain, origin: Origin.var }, provenanceFromFeatureStep(featureStep));
+                this.getWorld().eventLogger.log(featureStep, "info", `incremented ${term} to ${newNum}`, {
                     variable: term,
                     oldValue: presentVal,
                     newValue: newNum,
-                    operation: 'increment'
+                    operation: "increment",
                 });
                 return OK;
-            }
+            },
         },
         showEnv: {
-            gwta: 'show env',
-            expose: false,
+            gwta: "show env",
+            exposeMCP: false,
             action: () => {
-                // Obscure secret environment variables (matching /password/i)
                 const envVars = this.world.options.envVariables || {};
                 const shared = this.getWorld().shared;
                 const safeEnv = sanitizeObjectSecrets(envVars, (key) => shared.isSecret(key));
-                this.getWorld().eventLogger.info(`env: ${JSON.stringify(safeEnv, null, 2)}`, { env: safeEnv });
-                return Promise.resolve(OK);
-            }
+                const count = Object.keys(safeEnv).length;
+                return actionOKWithProducts({ _type: "Environment", _summary: `${count} environment variables`, env: safeEnv });
+            },
         },
         showVars: {
-            gwta: 'show vars',
-            action: () => {
+            gwta: "show vars",
+            action: async () => {
                 const shared = this.getWorld().shared;
-                const displayVars = Object.fromEntries(Object.entries(shared.all()).map(([key, variable]) => [key, variable.value]));
+                const displayVars = Object.fromEntries(Object.entries(await shared.all()).map(([key, variable]) => [key, variable.value]));
                 const safeVars = sanitizeObjectSecrets(displayVars, (key) => shared.isSecret(key));
-                this.getWorld().eventLogger.info(`vars: ${JSON.stringify(safeVars, null, 2)}`, { vars: safeVars });
-                return actionOK();
+                const count = Object.keys(safeVars).length;
+                return actionOKWithProducts({ _type: "Variables", _summary: `${count} variables`, vars: safeVars });
             },
         },
         set: {
-            gwta: 'set( empty)? {what: string} to {value: string}',
-            handlesUndefined: ['what', 'value'],
-            precludes: ['Haibun.prose'],
-            action: (args, featureStep) => {
+            gwta: "set( empty)? {what: string} to {value: string}",
+            handlesUndefined: ["what", "value"],
+            precludes: ["Haibun.prose"],
+            action: async (_, featureStep) => {
                 const { term: rawTerm, domain, origin } = featureStep.action.stepValuesMap.what;
-                const parsedValue = this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep, undefined, { secure: true });
+                const parsedValue = await this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep, undefined, {
+                    secure: true,
+                });
                 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);
+                const interpolated = await this.interpolateTemplate(rawTerm, featureStep);
                 if (interpolated.error)
                     return actionNotOK(interpolated.error);
                 const term = interpolated?.value;
-                const skip = shouldSkipEmpty(featureStep, term, this.getWorld().shared);
+                const skip = await 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 existing = await 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, secret: interpolated.secret || parsedValue.secret }, provenanceFromFeatureStep(featureStep));
                 return result;
-            }
+            },
         },
         setAs: {
-            gwta: 'set( empty)? {what} as {domain} to {value}',
-            handlesUndefined: ['what', 'domain', 'value'],
+            gwta: "set( empty)? {what} as {domain} to {value}",
+            handlesUndefined: ["what", "domain", "value"],
             precludes: [`${VariablesStepper.name}.set`],
-            action: ({ value, domain }, featureStep) => {
+            action: async ({ domain }, featureStep) => {
                 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, undefined, { secure: true });
+                const parsedValue = await this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep, undefined, {
+                    secure: true,
+                });
                 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);
+                const interpolated = await this.interpolateTemplate(rawTerm, featureStep);
                 if (interpolated.error)
                     return actionNotOK(interpolated.error);
                 const term = interpolated.value;
-                const skip = shouldSkipEmpty(featureStep, term, this.getWorld().shared);
+                const skip = await 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');
+                let effectiveDomain = domain ?? getStepTerm(featureStep, "domain");
                 if (effectiveDomain) {
-                    if (effectiveDomain.startsWith('read-only ')) {
-                        effectiveDomain = effectiveDomain.replace('read-only ', '');
+                    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('"')) {
+                if (typeof finalValue === "string" && finalValue.startsWith('"') && finalValue.endsWith('"')) {
                     finalValue = finalValue.slice(1, -1);
                 }
                 return trySetVariable(this.getWorld().shared, { term, value: finalValue, domain: effectiveDomain, origin, readonly, secret: interpolated.secret || parsedValue.secret }, provenanceFromFeatureStep(featureStep));
-            }
+            },
         },
         unset: {
-            gwta: 'unset {what: string}',
-            action: ({ what }, featureStep) => {
+            gwta: "unset {what: string}",
+            action: async (_, featureStep) => {
                 const { term } = featureStep.action.stepValuesMap.what;
-                this.getWorld().shared.unset(term);
-                return Promise.resolve(OK);
-            }
+                await this.getWorld().shared.unset(term);
+                return OK;
+            },
         },
         setRandom: {
             precludes: [`${VariablesStepper.name}.set`],
             gwta: `set( empty)? {what: string} to {length: number} random characters`,
-            handlesUndefined: ['what'],
-            action: ({ length }, featureStep) => {
+            handlesUndefined: ["what"],
+            action: async ({ length }, featureStep) => {
                 const { term } = featureStep.action.stepValuesMap.what;
                 if (length < 1 || length > 100) {
                     return actionNotOK(`length ${length} must be between 1 and 100`);
                 }
-                const skip = shouldSkipEmpty(featureStep, term, this.getWorld().shared);
+                const skip = await shouldSkipEmpty(featureStep, term, this.getWorld().shared);
                 if (skip)
                     return skip;
-                let rand = '';
+                let rand = "";
                 while (rand.length < length) {
-                    rand += Math.random().toString(36).substring(2, 2 + length);
+                    rand += Math.random()
+                        .toString(36)
+                        .substring(2, 2 + length);
                 }
                 rand = rand.substring(0, length);
                 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: (_, featureStep) => {
+            gwta: "variable {what} is {value}",
+            handlesUndefined: ["what", "value"],
+            action: async (_, featureStep) => {
                 const { term: rawTerm } = featureStep.action.stepValuesMap.what;
-                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                const interpolated = await 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, undefined, { secure: true });
+                const resolved = await this.getWorld().shared.resolveVariable({ term, origin: Origin.defined }, featureStep, undefined, {
+                    secure: true,
+                });
                 if (resolved.value === undefined || (resolved.origin !== Origin.var && resolved.origin !== Origin.env)) {
                     return actionNotOK(`${term} is not set`);
                 }
-                const parsedValue = this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep, undefined, { secure: true });
+                const parsedValue = await this.getWorld().shared.resolveVariable(featureStep.action.stepValuesMap.value, featureStep, undefined, {
+                    secure: true,
+                });
                 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(resolved.value) === JSON.stringify(compareVal) ? OK : actionNotOK(`${term} is ${JSON.stringify(resolved.value)}, not ${JSON.stringify(compareVal)}`);
-            }
+                const compareVal = this.getWorld().domains[domainKey].coerce({ term: "_cmp", value, domain: domainKey, origin: Origin.quoted }, featureStep, this.steppers);
+                return JSON.stringify(resolved.value) === JSON.stringify(compareVal)
+                    ? OK
+                    : actionNotOK(`${term} is ${JSON.stringify(resolved.value)}, not ${JSON.stringify(compareVal)}`);
+            },
         },
         isLessThan: {
-            gwta: 'variable {what} is less than {value}',
-            handlesUndefined: ['what', 'value'],
-            precludes: ['VariablesStepper.is'],
+            gwta: "variable {what} is less than {value}",
+            handlesUndefined: ["what", "value"],
+            precludes: ["VariablesStepper.is"],
             action: ({ what, value }, featureStep) => {
-                const term = getStepTerm(featureStep, 'what') ?? what;
-                return this.compareValues(featureStep, term, value, '<');
-            }
+                const term = getStepTerm(featureStep, "what") ?? what;
+                return this.compareValues(featureStep, term, value, "<");
+            },
         },
         isMoreThan: {
-            gwta: 'variable {what} is more than {value}',
-            handlesUndefined: ['what', 'value'],
-            precludes: ['VariablesStepper.is'],
+            gwta: "variable {what} is more than {value}",
+            handlesUndefined: ["what", "value"],
+            precludes: ["VariablesStepper.is"],
             action: ({ what, value }, featureStep) => {
-                const term = getStepTerm(featureStep, 'what') ?? what;
-                return this.compareValues(featureStep, term, value, '>');
-            }
+                const term = getStepTerm(featureStep, "what") ?? what;
+                return this.compareValues(featureStep, term, value, ">");
+            },
         },
         exists: {
-            gwta: 'variable {what} exists',
-            handlesUndefined: ['what'],
-            action: ({ what }, featureStep) => {
-                const term = (getStepTerm(featureStep, 'what') ?? what);
-                const sharedVars = this.getWorld().shared.all();
+            gwta: "variable {what} exists",
+            handlesUndefined: ["what"],
+            action: async ({ what }, featureStep) => {
+                const term = (getStepTerm(featureStep, "what") ?? what);
+                const sharedVars = await this.getWorld().shared.all();
                 if (sharedVars[term])
                     return OK;
                 const envVars = this.getWorld().options.envVariables || {};
                 return envVars[term] !== undefined ? OK : actionNotOK(`${what} not set`);
-            }
+            },
         },
         showVar: {
-            gwta: 'show var {what}',
-            handlesUndefined: ['what'],
-            action: (_, featureStep) => {
-                const rawTerm = getStepTerm(featureStep, 'what');
+            gwta: "show var {what}",
+            handlesUndefined: ["what"],
+            outputSchema: z.object({ term: z.string(), value: z.unknown(), domain: z.string().optional() }),
+            action: async (_, featureStep) => {
+                const rawTerm = getStepTerm(featureStep, "what");
                 if (rawTerm === undefined)
-                    return actionNotOK('variable not provided');
-                const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+                    return actionNotOK("variable not provided");
+                const interpolated = await this.interpolateTemplate(rawTerm, featureStep);
                 if (interpolated.error)
                     return actionNotOK(interpolated.error);
-                const term = interpolated.value || '';
+                const term = interpolated.value || "";
                 const shared = this.getWorld().shared;
-                const stepValue = shared.resolveVariable({ term, origin: Origin.defined }, featureStep);
+                const stepValue = await shared.resolveVariable({ term, origin: Origin.defined }, featureStep);
                 const isSecret = shared.isSecret(term) || stepValue.secret === true;
                 if (stepValue.value === undefined) {
                     this.getWorld().eventLogger.info(`${term} is undefined`);
+                    return actionOKWithProducts({ term, value: undefined, domain: stepValue.domain });
                 }
-                else {
-                    const displayValue = isSecret ? { ...stepValue, value: OBSCURED_VALUE } : stepValue;
-                    const provenance = featureStep.action.stepValuesMap.what.provenance?.map((p, i) => ({ [i]: { in: p.in, seq: p.seq.join(','), when: p.when } }));
-                    this.getWorld().eventLogger.info(`${term} is ${JSON.stringify({ ...displayValue, provenance }, null, 2)}`, { variable: term, value: displayValue });
-                }
-                return actionOK();
-            }
+                const displayValue = isSecret ? OBSCURED_VALUE : stepValue.value;
+                const summary = `${term} = ${typeof displayValue === "object" ? JSON.stringify(displayValue) : String(displayValue)}`;
+                return actionOKWithProducts({ _type: "Variable", _summary: summary, term, value: stepValue.value, domain: stepValue.domain });
+            },
         },
         showDomains: {
-            gwta: 'show domains',
-            action: () => {
+            gwta: "show domains",
+            action: async () => {
                 const domains = this.getWorld().domains;
-                const allVars = this.getWorld().shared.all();
-                const summary = {};
+                const allVars = await this.getWorld().shared.all();
+                const items = [];
+                // Collect vertexLabel→name mapping for base type edge targets
+                const labelToDomain = new Map();
+                for (const [dname, ddef] of Object.entries(domains)) {
+                    const vl = ddef.topology?.vertexLabel;
+                    labelToDomain.set(vl || dname, vl || dname);
+                }
                 for (const [name, def] of Object.entries(domains)) {
                     let members = 0;
                     for (const variable of Object.values(allVars)) {
-                        if (variable.domain && normalizeDomainKey(variable.domain) === name) {
+                        if (variable.domain && normalizeDomainKey(variable.domain) === name)
                             members++;
-                        }
-                    }
-                    let type = 'schema';
-                    if (def.values) {
-                        type = def.values;
                     }
-                    else if (def.description) {
-                        type = def.description;
+                    const description = def.values || def.description || "schema";
+                    const topology = def.topology;
+                    const vertexLabel = topology?.vertexLabel;
+                    const _edges = [];
+                    // Edges from topology (vertex→vertex relationships like Email→Contact)
+                    const topologyEdges = topology?.edges;
+                    if (topologyEdges) {
+                        for (const [edgeName, edge] of Object.entries(topologyEdges)) {
+                            if (edge.range && edge.range !== vertexLabel)
+                                _edges.push({ type: edgeName, targetId: edge.range });
+                        }
                     }
-                    summary[name] = {
-                        type,
-                        members,
-                        ordered: !!def.comparator
-                    };
+                    items.push({ name, description, members, ...(vertexLabel ? { vertexLabel } : {}), ...(_edges.length ? { _edges } : {}) });
                 }
-                this.getWorld().eventLogger.info(`Domains: ${JSON.stringify(summary, null, 2)}`, { domains: summary });
-                return OK;
-            }
+                return actionOKWithProducts({ _type: "Domain", _summary: `${items.length} domains`, items });
+            },
         },
         showDomain: {
-            gwta: 'show domain {name}',
-            handlesUndefined: ['name'],
-            action: (_, featureStep) => {
-                const name = getStepTerm(featureStep, 'name');
+            gwta: "show domain {name}",
+            handlesUndefined: ["name"],
+            action: async (_, featureStep) => {
+                const name = getStepTerm(featureStep, "name");
                 const domain = this.getWorld().domains[name];
                 if (!domain) {
                     return actionNotOK(`Domain "${name}" not found`);
                 }
                 const shared = this.getWorld().shared;
-                const allVars = shared.all();
+                const allVars = await shared.all();
                 const members = {};
                 for (const [key, variable] of Object.entries(allVars)) {
                     if (variable.domain && normalizeDomainKey(variable.domain) === name) {
                         members[key] = shared.isSecret(key) ? OBSCURED_VALUE : variable.value;
                     }
                 }
-                this.getWorld().eventLogger.info(`Domain "${name}": ${JSON.stringify({ ...domain, members }, null, 2)}`, { domain: name, ...domain, members });
-                return OK;
-            }
+                const memberCount = Object.keys(members).length;
+                return actionOKWithProducts({ _type: "Domain", _summary: `${name}: ${memberCount} members`, domain: name, ...domain, members });
+            },
         },
         // Membership check: value is in domain (enum or member values)
         // Handles quoted ("value"), braced ({var}), or bare (value) forms
@@ -367,23 +396,22 @@ class VariablesStepper extends AStepper {
         isIn: {
             match: /^(.+) is in ([a-zA-Z][a-zA-Z0-9 ]*)$/,
             fallback: true,
-            action: (_, featureStep) => {
+            action: async (_, 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('`'))) {
+                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('}')) {
+                if (valueTerm.startsWith("{") && valueTerm.endsWith("}")) {
                     valueTerm = valueTerm.slice(1, -1);
                 }
                 // Try to resolve as variable, fall back to literal
-                const resolvedValue = this.getWorld().shared.get(valueTerm, true);
+                const resolvedValue = await this.getWorld().shared.get(valueTerm, true);
                 const actualValue = resolvedValue !== undefined ? String(resolvedValue) : valueTerm;
                 const domainName = matchResult[2].trim();
                 const domainKey = normalizeDomainKey(domainName);
@@ -396,14 +424,12 @@ class VariablesStepper extends AStepper {
                     return OK;
                 }
                 // Check member values
-                const allVars = this.getWorld().shared.all();
+                const allVars = await 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}`);
-            }
+                    .filter((v) => v.domain && normalizeDomainKey(v.domain) === domainKey)
+                    .map((v) => String(v.value));
+                return memberValues.includes(actualValue) ? OK : actionNotOK(`"${actualValue}" is not in ${domainName}`);
+            },
         },
         // Pattern matching: glob-style patterns for human-readable matching
         // Usage: matches {host} with "*.wikipedia.org"
@@ -412,40 +438,40 @@ class VariablesStepper extends AStepper {
         // Supports * as wildcard (matches any characters)
         // Variables in pattern are interpolated: "{counter URI}*" resolves to actual value
         matches: {
-            gwta: 'matches {value} with {pattern}',
-            action: ({ value, pattern }, featureStep) => {
+            gwta: "matches {value} with {pattern}",
+            action: async ({ value, pattern }, featureStep) => {
                 // Interpolate value (e.g. "{request}/url" -> "req-1/url")
-                const interpolatedValue = this.interpolateTemplate(value, featureStep);
+                const interpolatedValue = await this.interpolateTemplate(value, featureStep);
                 if (interpolatedValue.error)
                     return actionNotOK(interpolatedValue.error);
                 const term = interpolatedValue.value;
                 // Resolve value as a variable (e.g., "WebPlaywright/currentURI" -> actual URL)
-                const resolvedValue = this.getWorld().shared.get(term, true);
+                const resolvedValue = await this.getWorld().shared.get(term, true);
                 const actualValue = resolvedValue !== undefined ? String(resolvedValue) : String(term);
                 // Interpolate variables in pattern (e.g., "{counter URI}*" -> "http://localhost:8123/*")
-                const interpolated = this.interpolateTemplate(pattern, featureStep);
+                const interpolated = await this.interpolateTemplate(pattern, featureStep);
                 if (interpolated.error)
                     return actionNotOK(interpolated.error);
                 const actualPattern = interpolated.value;
                 // Convert glob pattern to regex
                 // Escape regex special chars except *, then replace * with .*
-                const escaped = actualPattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-                const regexPattern = escaped.replace(/\*/g, '.*');
+                const escaped = actualPattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+                const regexPattern = escaped.replace(/\*/g, ".*");
                 const regex = new RegExp(`^${regexPattern}$`);
                 const isMatch = regex.test(actualValue);
-                return isMatch
-                    ? OK
-                    : actionNotOK(`"${actualValue}" does not match pattern "${actualPattern}"`);
-            }
+                return isMatch ? OK : actionNotOK(`"${actualValue}" does not match pattern "${actualPattern}"`);
+            },
         },
     };
     typedSteps = this.steps;
-    compareValues(featureStep, rawTerm, value, operator) {
-        const interpolated = this.interpolateTemplate(rawTerm, featureStep);
+    async compareValues(featureStep, rawTerm, value, operator) {
+        const interpolated = await 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, this.steppers, { secure: true });
+        const stored = await this.getWorld().shared.resolveVariable({ term, origin: Origin.var }, featureStep, this.steppers, {
+            secure: true,
+        });
         if (!stored) {
             return actionNotOK(`${term} is not set`);
         }
@@ -457,20 +483,20 @@ class VariablesStepper extends AStepper {
         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);
+            const parsed = await 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('"')) {
+        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 === '>') {
+        if (operator === ">") {
             return comparison > 0 ? OK : actionNotOK(`${term} is ${JSON.stringify(left)}, not ${JSON.stringify(right)}`);
         }
-        if (operator === '<') {
+        if (operator === "<") {
             return comparison < 0 ? OK : actionNotOK(`${term} is ${JSON.stringify(left)}, not ${JSON.stringify(right)}`);
         }
         return actionNotOK(`Unsupported operator: ${operator}`);
@@ -479,7 +505,7 @@ class VariablesStepper extends AStepper {
      * 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) {
+    async interpolateTemplate(template, featureStep) {
         const placeholderRegex = /\{([^}]+)\}/g;
         let result = template;
         let match;
@@ -490,7 +516,9 @@ class VariablesStepper extends AStepper {
             if (this.getWorld().shared.isSecret(varName)) {
                 secret = true;
             }
-            const resolved = this.getWorld().shared.resolveVariable({ term: varName, origin: Origin.defined }, featureStep, undefined, { secure: true });
+            const resolved = await this.getWorld().shared.resolveVariable({ term: varName, origin: Origin.defined }, featureStep, undefined, {
+                secure: true,
+            });
             if (resolved.value === undefined) {
                 return { error: `Variable ${varName} not found` };
             }
@@ -500,15 +528,15 @@ class VariablesStepper extends AStepper {
     }
     registerSubdomainFromStatement(domain, superdomains, featureStep) {
         try {
-            const fallback = getStepTerm(featureStep, 'superdomains') ?? featureStep.in;
+            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');
+                throw new Error("Superdomain set must specify at least one superdomain");
             }
             const uniqueNames = Array.from(new Set(superdomainNames));
-            const effectiveDomain = domain ?? getStepTerm(featureStep, 'domain');
+            const effectiveDomain = domain ?? getStepTerm(featureStep, "domain");
             if (!effectiveDomain)
-                return actionNotOK('Domain name must be provided');
+                return actionNotOK("Domain name must be provided");
             const domainKey = normalizeDomainKey(effectiveDomain);
             if (this.getWorld().domains[domainKey]) {
                 return actionNotOK(`Domain "${domainKey}" already exists`);
@@ -523,7 +551,7 @@ class VariablesStepper extends AStepper {
             });
             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(', ')}`;
+            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]]);
@@ -531,7 +559,7 @@ class VariablesStepper extends AStepper {
             }
             const schemaList = superdomainDefs.map((entry) => entry.schema);
             if (!schemaList.length) {
-                throw new Error('Superdomains did not expose any schema to derive from');
+                throw new Error("Superdomains did not expose any schema to derive from");
             }
             let mergedSchema = schemaList[0];
             for (let i = 1; i < schemaList.length; i++) {
@@ -552,15 +580,20 @@ class VariablesStepper extends AStepper {
     }
     registerValuesDomainFromStatement(domain, valueFragments, featureStep, options) {
         try {
-            const values = extractValuesFromFragments(valueFragments, getStepTerm(featureStep, 'values') ?? featureStep.in);
-            const effectiveDomain = domain ?? getStepTerm(featureStep, 'domain');
+            const values = extractValuesFromFragments(valueFragments, getStepTerm(featureStep, "values") ?? featureStep.in);
+            const effectiveDomain = domain ?? getStepTerm(featureStep, "domain");
             if (!effectiveDomain)
-                return actionNotOK('Domain name must be provided');
+                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 });
+            const definition = createEnumDomainDefinition({
+                name: domainKey,
+                values,
+                description: options?.description,
+                ordered: options?.ordered,
+            });
             registerDomains(this.getWorld(), [[definition]]);
             return OK;
         }
@@ -577,53 +610,58 @@ export function provenanceFromFeatureStep(featureStep) {
     return {
         in: featureStep.in,
         seq: featureStep.seqPath,
-        when: `${featureStep.action.stepperName}.steps.${featureStep.action.actionName}`
+        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 innerChunks = valueFragments
+            .map((fragment) => {
+            const raw = fragment.in ?? fragment.action?.stepValuesMap?.items?.term ?? "";
             const trimmed = raw.trim();
-            if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
                 return trimmed.slice(1, -1).trim();
             }
             return trimmed;
-        }).filter(Boolean);
-        const inner = innerChunks.join(' ').trim();
+        })
+            .filter(Boolean);
+        const inner = innerChunks.join(" ").trim();
         if (!inner) {
-            throw new Error('Set values cannot be empty');
+            throw new Error("Set values cannot be empty");
         }
         return parseQuotedOrWordList(inner);
     }
     if (fallback) {
         return parseBracketedValues(fallback);
     }
-    throw new Error('Set statement missing values');
+    throw new Error("Set statement missing values");
 };
 const parseBracketedValues = (raw) => {
     const trimmed = raw.trim();
-    const start = trimmed.indexOf('[');
-    const end = trimmed.lastIndexOf(']');
+    const start = trimmed.indexOf("[");
+    const end = trimmed.lastIndexOf("]");
     if (start === -1 || end === -1 || end <= start) {
-        throw new Error('Set values must include [ ]');
+        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);
+    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);
+    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') {
+    if (typeof left === "number" && typeof right === "number") {
         return left - right;
     }
     if (left instanceof Date && right instanceof Date) {
@@ -633,13 +671,23 @@ const compareDomainValues = (domain, left, right, domainName) => {
 };
 // ======== Helpers ========
 // Returns OK if "set empty" and variable exists
-function shouldSkipEmpty(featureStep, term, shared) {
-    return (featureStep.in.includes('set empty ') && shared.resolveVariable({ term, origin: Origin.var }, featureStep, undefined, { secure: true }).value !== undefined) ? OK : undefined;
+async function shouldSkipEmpty(featureStep, term, shared) {
+    if (!featureStep.in.includes("set empty "))
+        return undefined;
+    const resolved = await shared.resolveVariable({ term, origin: Origin.var }, featureStep, undefined, { secure: true });
+    return resolved.value !== undefined ? OK : undefined;
 }
 // Wraps shared.set in try/catch
-function trySetVariable(shared, opts, provenance) {
+async function trySetVariable(shared, opts, provenance) {
     try {
-        shared.set({ term: opts.term, value: opts.value, domain: opts.domain, origin: opts.origin, readonly: opts.readonly, secret: opts.secret }, provenance);
+        await shared.set({
+            term: opts.term,
+            value: opts.value,
+            domain: opts.domain,
+            origin: opts.origin,
+            readonly: opts.readonly,
+            secret: opts.secret,
+        }, provenance);
         return OK;
     }
     catch (e) {