@noodleseed/one 0.173.0 → 0.175.0

package/node_modules/@noodle-borg/compiler/dist/manifest/interaction-validation.js

@@ -0,0 +1,220 @@
+/**
+ * Compile-time checks for the `collect` interaction block (ADR 0240). Every field must be an input of
+ * the action it prepares with a control its schema can honor; every required action input must be
+ * collected or seeded from the opener's output; consent is a single fixed-true boolean; and the
+ * developer may only shorten the confirmation expiry within the platform ceiling. Valid blocks are
+ * emitted keyed by opener tool as system-owned artifact data, never onto the MCP-visible descriptor.
+ */
+/** The 24-hour platform ceiling (email profile default); every profile default sits below it. */
+const MAX_CONFIRMATION_EXPIRY_SECONDS = 86_400;
+export function compileToolInteractions(tools, artifactTools, errors) {
+    const byName = new Map(artifactTools.map((tool) => [tool.name, tool]));
+    const emitted = {};
+    tools.forEach((tool, index) => {
+        if (tool.interaction === undefined)
+            return;
+        const opener = byName.get(tool.name);
+        if (opener === undefined)
+            return; // a structural error on this tool was already recorded
+        const before = errors.length;
+        validateCollect(tool.interaction, opener, byName, `tools.${index}.interaction`, errors);
+        if (errors.length === before)
+            emitted[tool.name] = toArtifact(tool.interaction);
+    });
+    return Object.keys(emitted).length > 0 ? emitted : undefined;
+}
+function validateCollect(interaction, opener, byName, path, errors) {
+    const action = byName.get(interaction.action);
+    if (action === undefined) {
+        errors.push({
+            code: 'interaction_action_invalid',
+            path: `${path}.action`,
+            message: `interaction action "${interaction.action}" is not a declared tool`,
+        });
+        return;
+    }
+    if (action.annotations?.confirm !== true || action.annotations?.readOnlyHint === true) {
+        errors.push({
+            code: 'interaction_action_invalid',
+            path: `${path}.action`,
+            message: `interaction action "${action.name}" must set { confirm: true } and must not be read-only`,
+        });
+        return;
+    }
+    const inputs = objectProperties(action.inputSchema);
+    const required = new Set(stringList(action.inputSchema.required));
+    const outputs = objectProperties(opener.outputSchema);
+    const covered = new Set();
+    let consents = 0;
+    interaction.fields.forEach((field, index) => {
+        const fieldPath = `${path}.fields.${index}`;
+        const property = inputs[field.key];
+        if (property === undefined) {
+            errors.push({
+                code: 'interaction_field_unknown',
+                path: fieldPath,
+                message: `field "${field.key}" is not an input of action "${action.name}"`,
+            });
+            return;
+        }
+        covered.add(field.key);
+        if (field.control === 'consent')
+            consents += 1;
+        const mismatch = controlMismatch(field.control, property);
+        if (mismatch !== undefined) {
+            errors.push({
+                code: 'interaction_field_control_mismatch',
+                path: fieldPath,
+                message: `field "${field.key}" uses control "${field.control}" but its input schema ${mismatch}`,
+            });
+        }
+        if (field.optional === true) {
+            if (required.has(field.key) && !acceptsEmptyString(property)) {
+                errors.push({
+                    code: 'interaction_field_missing',
+                    path: fieldPath,
+                    message: `optional field "${field.key}" is required by action "${action.name}" and rejects the empty value; make the property optional or let it accept ""`,
+                });
+            }
+        }
+        else if (!required.has(field.key)) {
+            errors.push({
+                code: 'interaction_field_missing',
+                path: fieldPath,
+                message: `field "${field.key}" is not required by action "${action.name}"; mark it optional: true or require it`,
+            });
+        }
+    });
+    if (consents > 1) {
+        errors.push({
+            code: 'interaction_consent_invalid',
+            path: `${path}.fields`,
+            message: 'a collect interaction poses at most one consent question',
+        });
+    }
+    for (const [target, source] of Object.entries(interaction.initialValues ?? {})) {
+        const valuePath = `${path}.initialValues.${target}`;
+        if (inputs[target] === undefined) {
+            errors.push({
+                code: 'interaction_initial_value_unknown',
+                path: valuePath,
+                message: `initial value "${target}" is not an input of action "${action.name}"`,
+            });
+        }
+        else {
+            covered.add(target);
+        }
+        if (outputs[source.fromOutput] === undefined) {
+            errors.push({
+                code: 'interaction_initial_value_unknown',
+                path: `${valuePath}.fromOutput`,
+                message: `initial value "${target}" reads "${source.fromOutput}", which "${opener.name}" does not output`,
+            });
+        }
+    }
+    for (const key of required) {
+        if (covered.has(key))
+            continue;
+        errors.push({
+            code: 'interaction_field_missing',
+            path: `${path}.fields`,
+            message: `required input "${key}" of action "${action.name}" is neither a field nor an initial value`,
+        });
+    }
+    const seconds = interaction.confirmationExpiry?.seconds;
+    if (seconds !== undefined &&
+        !(Number.isInteger(seconds) && seconds >= 1 && seconds <= MAX_CONFIRMATION_EXPIRY_SECONDS)) {
+        errors.push({
+            code: 'interaction_expiry_invalid',
+            path: `${path}.confirmationExpiry.seconds`,
+            message: `confirmationExpiry.seconds must be a whole number from 1 to ${MAX_CONFIRMATION_EXPIRY_SECONDS}`,
+        });
+    }
+}
+/** Why `control` cannot render `property`, or undefined when the schema supports it. */
+function controlMismatch(control, property) {
+    switch (control) {
+        case 'consent':
+            return property.type === 'boolean' && isFixedTrue(property)
+                ? undefined
+                : 'is not a boolean fixed to true';
+        case 'select':
+            return property.type === 'string' && isStringEnum(property.enum)
+                ? undefined
+                : 'is not an enum of strings';
+        case 'email':
+            if (property.type !== 'string')
+                return 'is not a string';
+            return property.format === undefined || property.format === 'email'
+                ? undefined
+                : `declares format "${String(property.format)}"`;
+        default:
+            return property.type === 'string' ? undefined : 'is not a string';
+    }
+}
+function isFixedTrue(property) {
+    if (property.const === true)
+        return true;
+    return Array.isArray(property.enum) && property.enum.length === 1 && property.enum[0] === true;
+}
+function isStringEnum(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === 'string');
+}
+/**
+ * Whether `""` satisfies a string property, so an optional field the action still requires can be
+ * submitted blank. Any format, a positive minLength, or a pattern/enum/const rejecting `""` means no.
+ */
+function acceptsEmptyString(property) {
+    if (property.type !== 'string' || property.format !== undefined)
+        return false;
+    if (typeof property.minLength === 'number' && property.minLength > 0)
+        return false;
+    if (property.const !== undefined && property.const !== '')
+        return false;
+    if (Array.isArray(property.enum) && !property.enum.includes(''))
+        return false;
+    return typeof property.pattern === 'string' ? patternMatchesEmpty(property.pattern) : true;
+}
+function patternMatchesEmpty(pattern) {
+    for (const flags of ['u', '']) {
+        try {
+            return new RegExp(pattern, flags).test('');
+        }
+        catch {
+            // An invalid pattern under this flag set; try the next, then fail closed.
+        }
+    }
+    return false;
+}
+function objectProperties(schema) {
+    const properties = schema?.properties;
+    if (typeof properties !== 'object' || properties === null || Array.isArray(properties))
+        return {};
+    return Object.fromEntries(Object.entries(properties).flatMap(([key, value]) => typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? [[key, value]]
+        : []));
+}
+function stringList(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+}
+function toArtifact(interaction) {
+    return {
+        kind: 'collect',
+        action: interaction.action,
+        fields: interaction.fields.map((field) => ({
+            key: field.key,
+            control: field.control,
+            ...(field.private === true ? { private: true } : {}),
+            ...(field.optional === true ? { optional: true } : {}),
+        })),
+        ...(interaction.initialValues === undefined
+            ? {}
+            : { initialValues: interaction.initialValues }),
+        review: 'all',
+        outcome: { success: interaction.outcome.success },
+        ...(interaction.confirmationExpiry === undefined
+            ? {}
+            : { confirmationExpirySeconds: interaction.confirmationExpiry.seconds }),
+    };
+}
+//# sourceMappingURL=interaction-validation.js.map

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -11,10 +11,10 @@ export declare const manifestV1Schema: z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -557,10 +557,10 @@ export declare const manifestV2Schema: z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -1238,6 +1238,34 @@ export declare const manifestV2Schema: z.ZodObject<{
             output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
         contextProvider: z.ZodOptional<z.ZodLiteral<true>>;
+        interaction: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"collect">;
+            action: z.ZodString;
+            initialValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                fromOutput: z.ZodString;
+            }, z.core.$strict>>>;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                control: z.ZodEnum<{
+                    email: "email";
+                    text: "text";
+                    textarea: "textarea";
+                    phone: "phone";
+                    url: "url";
+                    select: "select";
+                    consent: "consent";
+                }>;
+                private: z.ZodOptional<z.ZodLiteral<true>>;
+                optional: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+            review: z.ZodLiteral<"all">;
+            outcome: z.ZodObject<{
+                success: z.ZodString;
+            }, z.core.$strict>;
+            confirmationExpiry: z.ZodOptional<z.ZodObject<{
+                seconds: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     connectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
@@ -1285,10 +1313,10 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -1830,10 +1858,10 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -2511,6 +2539,34 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
         contextProvider: z.ZodOptional<z.ZodLiteral<true>>;
+        interaction: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"collect">;
+            action: z.ZodString;
+            initialValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                fromOutput: z.ZodString;
+            }, z.core.$strict>>>;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                control: z.ZodEnum<{
+                    email: "email";
+                    text: "text";
+                    textarea: "textarea";
+                    phone: "phone";
+                    url: "url";
+                    select: "select";
+                    consent: "consent";
+                }>;
+                private: z.ZodOptional<z.ZodLiteral<true>>;
+                optional: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+            review: z.ZodLiteral<"all">;
+            outcome: z.ZodObject<{
+                success: z.ZodString;
+            }, z.core.$strict>;
+            confirmationExpiry: z.ZodOptional<z.ZodObject<{
+                seconds: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     connectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -7,6 +7,7 @@ import { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES } from '../wi
 import { agentGuideSchema } from './agent-guide-schema.js';
 import { serverAuthSchema, serverAuthV2Schema } from './auth-schema.js';
 import { assistantOriginOrVariableSchema, httpsUrlSchema, managedVariableExpressionSchema, serverBrandingSchema, } from './branding-schema.js';
+import { toolInteractionSchema } from './interaction-schema.js';
 import { NAME_PATTERN } from './naming.js';
 /**
  * Zod schema for Core v1 and v2 manifests (ADRs 0150 and 0157). V1 remains accepted unchanged;
@@ -115,7 +116,12 @@ const toolSchema = z.object({
         .optional(),
     fulfilment: fulfilmentSchema,
 });
-const toolV2Schema = toolSchema.extend({ contextProvider: z.literal(true).optional() });
+const toolV2Schema = toolSchema.extend({
+    contextProvider: z.literal(true).optional(),
+    // Additive optional field: a v1.x minor under ADR 0150. Bounded `collect` interaction metadata
+    // (ADR 0240) an opener tool declares for one confirmed action; references are checked in compile().
+    interaction: toolInteractionSchema.optional(),
+});
 /**
  * An MCP resource. Like a tool, it carries a `fulfilment` (it can return a constant or call connectors);
  * its `uri` is a fixed URI or a simple `{var}` URI template (validated in compile()). The compile pass

package/node_modules/@noodle-borg/compiler/dist/manifest/website-projection.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactPrompt, ArtifactResource, ArtifactTool } from '../artifact/types.js';
+import type { ArtifactCollectInteraction, ArtifactPrompt, ArtifactResource, ArtifactTool, OperationRef } from '../artifact/types.js';
 import type { CompileError } from '../errors.js';
 /**
  * Compile-time enforcement of website assistant surfaces (ADR 0201, amended 2026-08-12). These are
@@ -36,9 +36,17 @@ export interface WebsiteProjectionSurfaces {
     readonly knowledge?: readonly {
         readonly name: string;
     }[] | undefined;
+    /** `collect` interactions keyed by opener (ADR 0240); a messaging surface presents them natively. */
+    readonly interactions?: Readonly<Record<string, ArtifactCollectInteraction>> | undefined;
+    /** Declared connector aliases, so a shape-only operation ref still names its connector id. */
+    readonly connectors?: Readonly<Record<string, {
+        readonly id: string;
+    }>> | undefined;
 }
 /** A tool touches identity when it reads `${user}` or requires verified claims (ADR 0185). */
 export declare function anonymousBehavior(tool: ArtifactTool): 'public-safe' | 'requires-identity';
 export declare function validateWebsiteProjection(assistant: AssistantProjectionInput | undefined, surfaces: WebsiteProjectionSurfaces): readonly CompileError[];
+/** Resolved refs carry the connector id; a shape-only ref is looked up through its declared alias. */
+export declare function isNativeRecordsOperation(operation: OperationRef, connectors: WebsiteProjectionSurfaces['connectors']): boolean;
 export {};
 //# sourceMappingURL=website-projection.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/manifest/website-projection.js

@@ -1,3 +1,4 @@
+import { RECORD_CONNECTOR_ID } from '../native-record-operations.js';
 import { collectPaths } from './expression.js';
 /** A tool touches identity when it reads `${user}` or requires verified claims (ADR 0185). */
 export function anonymousBehavior(tool) {
@@ -40,16 +41,11 @@ export function validateWebsiteProjection(assistant, surfaces) {
             if (tool === undefined)
                 return;
             const path = `tools.${tool.name}`;
-            if (surface.kind === 'messaging' &&
-                (tool.annotations?.readOnlyHint !== true ||
-                    tool._meta?.ui !== undefined ||
-                    tool.fulfilment.kind === 'operation' ||
-                    tool.fulfilment.steps.some((step) => step.kind === 'operation'))) {
-                errors.push({
-                    code: 'assistant_messaging_unsupported',
-                    path,
-                    message: `"${tool.name}" requires a write, connector, or UI renderer not enabled for this messaging slice`,
-                });
+            if (surface.kind === 'messaging') {
+                const selected = new Set(surface.capabilities?.flatMap((entry) => (entry.kind === 'tool' ? [entry.name] : [])));
+                const requirement = messagingRequirement(tool, selected, surfaces);
+                if (requirement !== undefined)
+                    errors.push({ ...requirement, path });
             }
             if (surface.mode === 'public' && anonymousBehavior(tool) === 'requires-identity') {
                 errors.push({
@@ -73,6 +69,58 @@ export function validateWebsiteProjection(assistant, surfaces) {
     });
     return errors;
 }
+/**
+ * What a messaging profile can present (ADR 0240): pure reads and knowledge as before, plus a
+ * `collect` opener whose confirmed action is selected beside it and saves one native record. The
+ * opener may carry a browser widget (the website keeps its React view) because the profile renders
+ * the same block as natural collection. Anything else names the requirement it lacks.
+ */
+function messagingRequirement(tool, selected, surfaces) {
+    const operations = operationRefs(tool.fulfilment);
+    const interaction = surfaces.interactions?.[tool.name];
+    if (interaction !== undefined && !selected.has(interaction.action)) {
+        return {
+            code: 'channel_dependency_missing',
+            message: `"${tool.name}" requires its confirmed action "${interaction.action}", which is not selected on this messaging surface`,
+        };
+    }
+    const opensCollection = interaction !== undefined;
+    const isCollectAction = [...selected].some((name) => surfaces.interactions?.[name]?.action === tool.name);
+    if (isCollectAction) {
+        const [operation] = operations;
+        if (operations.length === 1 &&
+            operation !== undefined &&
+            isNativeRecordsOperation(operation, surfaces.connectors)) {
+            return undefined;
+        }
+        return {
+            code: 'channel_requirement_unsupported',
+            message: `"${tool.name}" requires a connector call the messaging profile does not provide; a collect action saves exactly one native record`,
+        };
+    }
+    const requirements = [
+        ...(tool.annotations?.readOnlyHint !== true ? ['a write'] : []),
+        ...(operations.length > 0 ? ['a connector call'] : []),
+        ...(tool._meta?.ui?.resourceUri !== undefined && !opensCollection ? ['a UI renderer'] : []),
+    ];
+    if (requirements.length === 0)
+        return undefined;
+    return {
+        code: 'channel_requirement_unsupported',
+        message: `"${tool.name}" requires ${requirements.join(' and ')} that the messaging profile does not provide without a collect interaction`,
+    };
+}
+function operationRefs(fulfilment) {
+    return fulfilment.kind === 'operation'
+        ? [fulfilment.operationRef]
+        : fulfilment.steps.flatMap((step) => (step.kind === 'operation' ? [step.operationRef] : []));
+}
+/** Resolved refs carry the connector id; a shape-only ref is looked up through its declared alias. */
+export function isNativeRecordsOperation(operation, connectors) {
+    return operation.resolved
+        ? operation.connectorId === RECORD_CONNECTOR_ID
+        : connectors?.[operation.connector]?.id === RECORD_CONNECTOR_ID;
+}
 /**
  * Reads every expression a fulfilment evaluates — one operation's args, or a flow's output plus each
  * step's args and its `if` guard, since a condition can read `${user}` just as an argument can.

package/node_modules/@noodle-borg/control-plane/dist/in-memory-atomic-state.d.ts

@@ -0,0 +1,8 @@
+/** Development-only composition. PostgreSQL remains the production transaction authority. */
+export declare class InMemoryAtomicState {
+    #private;
+    /** Values retain normal Map reference semantics; owners validate and copy their records. */
+    map<K, V>(): Map<K, V>;
+    run<T>(operation: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=in-memory-atomic-state.d.ts.map

package/node_modules/@noodle-borg/control-plane/dist/in-memory-atomic-state.js

@@ -0,0 +1,136 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** Development-only composition. PostgreSQL remains the production transaction authority. */
+export class InMemoryAtomicState {
+    #current = new AsyncLocalStorage();
+    #tail = Promise.resolve();
+    /** Values retain normal Map reference semantics; owners validate and copy their records. */
+    map() {
+        return new AtomicMap(() => {
+            const transaction = this.#current.getStore();
+            if (transaction?.closed)
+                throw new Error('memory transaction is closed');
+            return transaction;
+        });
+    }
+    async run(operation) {
+        const inherited = this.#current.getStore();
+        if (inherited) {
+            if (inherited.closed)
+                throw new Error('memory transaction is closed');
+            inherited.pending++;
+            try {
+                return await operation();
+            }
+            catch (error) {
+                inherited.failure ??= { error };
+                throw error;
+            }
+            finally {
+                inherited.pending--;
+            }
+        }
+        const prior = this.#tail;
+        let release = () => { };
+        this.#tail = new Promise((done) => {
+            release = done;
+        });
+        await prior;
+        const transaction = { participants: new Map(), closed: false, pending: 0 };
+        try {
+            const result = await this.#current.run(transaction, operation);
+            if (transaction.failure)
+                throw transaction.failure.error;
+            if (transaction.pending !== 0)
+                throw new Error('memory transaction has unfinished work');
+            // Validate every generation before any publication. Nonparticipating mutations survive a conflict.
+            for (const participant of transaction.participants.values())
+                participant.validate();
+            for (const participant of transaction.participants.values())
+                participant.commit();
+            return result;
+        }
+        finally {
+            transaction.closed = true;
+            release();
+        }
+    }
+}
+/** Private maps never restore a process-wide snapshot or expose staged entries to another request. */
+class AtomicMap {
+    transaction;
+    [Symbol.toStringTag] = 'Map';
+    #entries = new Map();
+    #generation = 0;
+    constructor(transaction) {
+        this.transaction = transaction;
+    }
+    #view(mutate = false) {
+        const transaction = this.transaction();
+        if (!transaction) {
+            if (mutate)
+                this.#generation++;
+            return this.#entries;
+        }
+        let participant = transaction.participants.get(this);
+        if (!participant) {
+            const generation = this.#generation;
+            const draft = { entries: new Map(this.#entries), dirty: false };
+            participant = {
+                value: draft,
+                validate: () => {
+                    if (generation !== this.#generation)
+                        throw new Error('memory transaction conflict');
+                },
+                commit: () => {
+                    if (!draft.dirty)
+                        return;
+                    this.#entries = draft.entries;
+                    this.#generation++;
+                },
+            };
+            transaction.participants.set(this, participant);
+        }
+        // The unexposed map instance is the type-stable key for this participant.
+        const draft = participant.value;
+        if (mutate)
+            draft.dirty = true;
+        return draft.entries;
+    }
+    get size() {
+        return this.#view().size;
+    }
+    get(key) {
+        return this.#view().get(key);
+    }
+    has(key) {
+        return this.#view().has(key);
+    }
+    set(key, value) {
+        this.#view(true).set(key, value);
+        return this;
+    }
+    delete(key) {
+        return this.#view(true).delete(key);
+    }
+    clear() {
+        this.#view(true).clear();
+    }
+    entries() {
+        return this.#view().entries();
+    }
+    keys() {
+        return this.#view().keys();
+    }
+    values() {
+        return this.#view().values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callback, thisArg) {
+        this.#view().forEach((value, key) => {
+            callback.call(thisArg, value, key, this);
+        });
+    }
+}
+//# sourceMappingURL=in-memory-atomic-state.js.map

package/node_modules/@noodle-borg/control-plane/dist/in-memory-control-plane-store.d.ts

@@ -1,10 +1,17 @@
 import type { CreateOrgWithOwnerInput, OrgMemberRecord, OrgRecord, OrgRole, PersonalWorkspaceProvisionInput, PersonalWorkspaceProvisionResult, WelcomeEmailRecord } from './contracts.js';
+import { InMemoryAtomicState } from './in-memory-atomic-state.js';
 import { InMemoryOrganizationStore } from './in-memory-organization-store.js';
 /** Portable organization state. Commercial account provisioning is an optional module side effect. */
 export declare class InMemoryControlPlaneStore extends InMemoryOrganizationStore {
     #private;
     constructor(options?: {
         readonly now?: () => Date;
+        readonly transactions?: InMemoryAtomicState;
+        /** Fresh-only local participant; all stores must share the supplied transaction context. */
+        readonly personalWorkspaceCreated?: (input: {
+            readonly org: string;
+            readonly ownerSubject: string;
+        }) => Promise<void>;
     });
     provisionPersonalWorkspace(input: PersonalWorkspaceProvisionInput): Promise<PersonalWorkspaceProvisionResult>;
     createOrgWithOwner(input: CreateOrgWithOwnerInput): Promise<OrgRecord>;