@wildo-ai/saas-models 1.0.1 → 1.1.0

package/dist/esm/flows-actors/meta-workflows/execution-binding-vocabularies.meta-workflows.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-binding-vocabularies.meta-workflows.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/execution-binding-vocabularies.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,EAAE;AACF,iGAAiG;AACjG,kGAAkG;AAClG,mDAAmD;AACnD,EAAE;AACF,oGAAoG;AACpG,+FAA+F;AAC/F,oGAAoG;AACpG,kGAAkG;AAClG,iGAAiG;AACjG,mCAAmC;AACnC,EAAE;AACF,kGAAkG;AAClG,kEAAkE;AAClE,EAAE;AACF,6FAA6F;AAC7F,yFAAyF;AACzF,+DAA+D;AAE/D;;;;;GAKG;AACH,MAAM,CAAN,IAAY,mCAWX;AAXD,WAAY,mCAAmC;IAC7C,4DAAqB,CAAA;IACrB,4DAAqB,CAAA;IACrB,0DAAmB,CAAA;IACnB,wEAAiC,CAAA;IACjC,kEAA2B,CAAA;IAC3B,8DAAuB,CAAA;IACvB,wDAAiB,CAAA;IACjB,8DAAuB,CAAA;IACvB,0DAAmB,CAAA;IACnB,gEAAyB,CAAA;AAC3B,CAAC,EAXW,mCAAmC,KAAnC,mCAAmC,QAW9C;AAED,MAAM,CAAC,MAAM,iDAAiD,GAC5D;IACE,mCAAmC,CAAC,SAAS;IAC7C,mCAAmC,CAAC,MAAM;IAC1C,mCAAmC,CAAC,SAAS;IAC7C,mCAAmC,CAAC,OAAO;IAC3C,mCAAmC,CAAC,UAAU;CAC/C,CAAC;AAEJ,MAAM,mDAAmD,GAErD,IAAI,GAAG,CAAC,iDAAiD,CAAC,CAAC;AAE/D,0FAA0F;AAC1F,MAAM,CAAN,IAAY,yCAEX;AAFD,WAAY,yCAAyC;IACnD,gEAAmB,CAAA;AACrB,CAAC,EAFW,yCAAyC,KAAzC,yCAAyC,QAEpD;AAED,6EAA6E;AAC7E,MAAM,CAAN,IAAY,+CAGX;AAHD,WAAY,+CAA+C;IACzD,gFAA6B,CAAA;IAC7B,wEAAqB,CAAA;AACvB,CAAC,EAHW,+CAA+C,KAA/C,+CAA+C,QAG1D","sourcesContent":["// `MetaWorkflow_ExecutionBindingRole` is NOT declared here.\n//\n// It appears on `Actors_Task_Context.continuityBinding`, which the package ROOT publishes, so it\n// lives at the Actor-Task boundary — `flows-actors/task-continuity-binding.actors.shared.schemas`\n// — and is reachable from `@wildo-ai/saas-models`.\n//\n// Why moving it was necessary, stated precisely: TypeScript writes an inferred type by NAME, and it\n// will only use a module specifier the consuming program has ALREADY RESOLVED. This module was\n// published by `@wildo-ai/saas-models/meta-workflows`, and that did not help — a consumer importing\n// only the package root never resolves that subpath, so the sole remaining name for the declaring\n// file was a `node_modules/.../dist/esm/...` path, which TypeScript refuses (`TS2742`/`TS2883`).\n// Publication is not reachability.\n//\n// Deliberately NOT a JSDoc block: declaration emit would reattach it to the next exported symbol,\n// making it that symbol's hover documentation for every consumer.\n//\n// The rest of the execution-binding vocabulary stays in this module because no root-exported\n// contract references it. Import the role from the boundary module; do not re-declare or\n// re-export it here — one vocabulary member, one named source.\n\n/**\n * Concrete lifecycle of one semantic-to-physical execution attempt.\n *\n * Terminal states are absorbing. A semantic retry creates a new binding with\n * a greater attempt ordinal; it never reopens a terminal binding.\n */\nexport enum MetaWorkflow_ExecutionBindingStatus {\n  PREPARED = 'PREPARED',\n  ADMITTED = 'ADMITTED',\n  RUNNING = 'RUNNING',\n  INPUT_REQUIRED = 'INPUT_REQUIRED',\n  RECONCILING = 'RECONCILING',\n  COMPLETED = 'COMPLETED',\n  FAILED = 'FAILED',\n  CANCELLED = 'CANCELLED',\n  ABORTED = 'ABORTED',\n  CONFLICTED = 'CONFLICTED',\n}\n\nexport const META_WORKFLOW_TERMINAL_EXECUTION_BINDING_STATUSES: readonly MetaWorkflow_ExecutionBindingStatus[] =\n  [\n    MetaWorkflow_ExecutionBindingStatus.COMPLETED,\n    MetaWorkflow_ExecutionBindingStatus.FAILED,\n    MetaWorkflow_ExecutionBindingStatus.CANCELLED,\n    MetaWorkflow_ExecutionBindingStatus.ABORTED,\n    MetaWorkflow_ExecutionBindingStatus.CONFLICTED,\n  ];\n\nconst META_WORKFLOW_TERMINAL_EXECUTION_BINDING_STATUS_SET:\n  ReadonlySet<MetaWorkflow_ExecutionBindingStatus> =\n    new Set(META_WORKFLOW_TERMINAL_EXECUTION_BINDING_STATUSES);\n\n/** Internal capability direction. Meta-workflow execution consumes; it never provides. */\nexport enum MetaWorkflow_ExecutionCapabilityDirection {\n  CONSUME = 'CONSUME',\n}\n\n/** Whether invocation-time authority was unnecessary or exactly resolved. */\nexport enum MetaWorkflow_ExecutionAuthorityResolutionStatus {\n  NOT_REQUIRED = 'NOT_REQUIRED',\n  RESOLVED = 'RESOLVED',\n}\n"]}

package/dist/esm/flows-actors/meta-workflows/portable-primitives.meta-workflows.shared.schemas.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+/**
+ * Internal lexical leaves shared by the portable meta-workflow contracts.
+ *
+ * This file intentionally owns no durable record and is not exported from the
+ * package root. It IS, however, in the root barrel's transitive import closure:
+ * `flows-actors/task-continuity-binding.actors.shared.schemas` needs
+ * `MetaWorkflow_PositiveOrdinalSchema`. That crossing is waived at the importing
+ * site and measured safe — everything published here is structural, so no
+ * consumer ever needs to NAME this module. Adding a nominal type (an `enum`, a
+ * `class`) would change that; see the waiver before doing so. Its purpose is to keep the exact lexical rules for digests,
+ * semantic refs, UUIDs, and positive versions single-sourced without creating
+ * an Action ↔ Decision ↔ Catalog dependency cycle.
+ */
+declare const _MetaWorkflow_Sha256DigestSchema: z.ZodString;
+export declare const MetaWorkflow_Sha256DigestSchema: typeof _MetaWorkflow_Sha256DigestSchema;
+/**
+ * Stable semantic refs have at least two namespace segments. Existing
+ * methodology refs such as `top_down.market-analysis` and contract refs such
+ * as `saas-specifications:MarketSnapshot` both satisfy this deliberately
+ * transport-neutral grammar.
+ */
+declare const _MetaWorkflow_NamespacedRefSchema: z.ZodString;
+export declare const MetaWorkflow_NamespacedRefSchema: typeof _MetaWorkflow_NamespacedRefSchema;
+declare const _MetaWorkflow_OpaqueRefSchema: z.ZodString;
+export declare const MetaWorkflow_OpaqueRefSchema: typeof _MetaWorkflow_OpaqueRefSchema;
+declare const _MetaWorkflow_PositiveVersionSchema: z.ZodNumber;
+export declare const MetaWorkflow_PositiveVersionSchema: typeof _MetaWorkflow_PositiveVersionSchema;
+declare const _MetaWorkflow_PositiveOrdinalSchema: z.ZodNumber;
+export declare const MetaWorkflow_PositiveOrdinalSchema: typeof _MetaWorkflow_PositiveOrdinalSchema;
+declare const _MetaWorkflow_NonNegativeRevisionSchema: z.ZodNumber;
+export declare const MetaWorkflow_NonNegativeRevisionSchema: typeof _MetaWorkflow_NonNegativeRevisionSchema;
+declare const _MetaWorkflow_LowercaseUuidV4Schema: z.ZodUUID;
+export declare const MetaWorkflow_LowercaseUuidV4Schema: typeof _MetaWorkflow_LowercaseUuidV4Schema;
+declare const _MetaWorkflow_IsoDateTimeSchema: z.ZodISODateTime;
+export declare const MetaWorkflow_IsoDateTimeSchema: typeof _MetaWorkflow_IsoDateTimeSchema;
+declare const _MetaWorkflow_NonNegativeFiniteNumberSchema: z.ZodNumber;
+export declare const MetaWorkflow_NonNegativeFiniteNumberSchema: typeof _MetaWorkflow_NonNegativeFiniteNumberSchema;
+/** Whether a sequence contains no repeated scalar value. */
+export declare function metaWorkflowValuesAreUnique(values: ReadonlyArray<string | number>): boolean;
+/**
+ * Whether homogeneous scalar values are already in canonical ascending order.
+ *
+ * Strings use deterministic UTF-16 code-unit order; numeric version arrays
+ * use numeric order so version `10` follows version `2` rather than sorting
+ * between `1` and `2`.
+ */
+/**
+ * The ONE canonical string order for every portable meta-workflow collection.
+ *
+ * It is UTF-16 code-unit order — exactly what `metaWorkflowValuesAreLexicallySorted`
+ * validates — and deliberately NOT `String.prototype.localeCompare`, whose result
+ * depends on the host ICU locale. A producer that sorts with `localeCompare` and a
+ * validator that checks code-unit order disagree for ordinary refs (`a-b` vs `a_b`,
+ * `alpha` vs `Beta`), which turns a correct value into a parse failure on one
+ * machine and a different canonical digest on another.
+ */
+export declare function compareMetaWorkflowCanonicalStrings(left: string, right: string): number;
+export declare function metaWorkflowValuesAreLexicallySorted(values: ReadonlyArray<string | number>): boolean;
+export {};
+//# sourceMappingURL=portable-primitives.meta-workflows.shared.schemas.d.ts.map

package/dist/esm/flows-actors/meta-workflows/portable-primitives.meta-workflows.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-primitives.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/portable-primitives.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;GAYG;AAEH,QAAA,MAAM,gCAAgC,aAKnC,CAAC;AACJ,eAAO,MAAM,+BAA+B,EAAE,OAAO,gCACnB,CAAC;AAEnC;;;;;GAKG;AACH,QAAA,MAAM,iCAAiC,aAMpC,CAAC;AACJ,eAAO,MAAM,gCAAgC,EAAE,OAAO,iCACnB,CAAC;AAEpC,QAAA,MAAM,6BAA6B,aAK/B,CAAC;AACL,eAAO,MAAM,4BAA4B,EAAE,OAAO,6BACnB,CAAC;AAEhC,QAAA,MAAM,mCAAmC,aAA8B,CAAC;AACxE,eAAO,MAAM,kCAAkC,EAAE,OAAO,mCACnB,CAAC;AAEtC,QAAA,MAAM,mCAAmC,aAA8B,CAAC;AACxE,eAAO,MAAM,kCAAkC,EAAE,OAAO,mCACnB,CAAC;AAEtC,QAAA,MAAM,uCAAuC,aAAiC,CAAC;AAC/E,eAAO,MAAM,sCAAsC,EAAE,OAAO,uCACnB,CAAC;AAE1C,QAAA,MAAM,mCAAmC,WAAyB,CAAC;AACnE,eAAO,MAAM,kCAAkC,EAAE,OAAO,mCACnB,CAAC;AAEtC,QAAA,MAAM,+BAA+B,kBAAmB,CAAC;AACzD,eAAO,MAAM,8BAA8B,EAAE,OAAO,+BACnB,CAAC;AAElC,QAAA,MAAM,2CAA2C,aAGjC,CAAC;AACjB,eAAO,MAAM,0CAA0C,EAAE,OAAO,2CACnB,CAAC;AAE9C,4DAA4D;AAC5D,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,GACrC,OAAO,CAET;AAED;;;;;;GAMG;AACH;;;;;;;;;GASG;AACH,wBAAgB,mCAAmC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvF;AAED,wBAAgB,oCAAoC,CAClD,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,GACrC,OAAO,CAiBT"}

package/dist/esm/flows-actors/meta-workflows/portable-primitives.meta-workflows.shared.schemas.js

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+/**
+ * Internal lexical leaves shared by the portable meta-workflow contracts.
+ *
+ * This file intentionally owns no durable record and is not exported from the
+ * package root. It IS, however, in the root barrel's transitive import closure:
+ * `flows-actors/task-continuity-binding.actors.shared.schemas` needs
+ * `MetaWorkflow_PositiveOrdinalSchema`. That crossing is waived at the importing
+ * site and measured safe — everything published here is structural, so no
+ * consumer ever needs to NAME this module. Adding a nominal type (an `enum`, a
+ * `class`) would change that; see the waiver before doing so. Its purpose is to keep the exact lexical rules for digests,
+ * semantic refs, UUIDs, and positive versions single-sourced without creating
+ * an Action ↔ Decision ↔ Catalog dependency cycle.
+ */
+const _MetaWorkflow_Sha256DigestSchema = z
+    .string()
+    .regex(/^sha256:[0-9a-f]{64}$/, 'expected `sha256:<64-hex-lowercase>`');
+export const MetaWorkflow_Sha256DigestSchema = _MetaWorkflow_Sha256DigestSchema;
+/**
+ * Stable semantic refs have at least two namespace segments. Existing
+ * methodology refs such as `top_down.market-analysis` and contract refs such
+ * as `saas-specifications:MarketSnapshot` both satisfy this deliberately
+ * transport-neutral grammar.
+ */
+const _MetaWorkflow_NamespacedRefSchema = z
+    .string()
+    .min(3)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9_-]*(?:[.:/][A-Za-z0-9][A-Za-z0-9_-]*)+$/, 'expected a non-empty namespaced ref');
+export const MetaWorkflow_NamespacedRefSchema = _MetaWorkflow_NamespacedRefSchema;
+const _MetaWorkflow_OpaqueRefSchema = z
+    .string()
+    .min(1)
+    .refine((value) => value === value.trim(), {
+    message: 'opaque refs must not contain surrounding whitespace',
+});
+export const MetaWorkflow_OpaqueRefSchema = _MetaWorkflow_OpaqueRefSchema;
+const _MetaWorkflow_PositiveVersionSchema = z.number().int().positive();
+export const MetaWorkflow_PositiveVersionSchema = _MetaWorkflow_PositiveVersionSchema;
+const _MetaWorkflow_PositiveOrdinalSchema = z.number().int().positive();
+export const MetaWorkflow_PositiveOrdinalSchema = _MetaWorkflow_PositiveOrdinalSchema;
+const _MetaWorkflow_NonNegativeRevisionSchema = z.number().int().nonnegative();
+export const MetaWorkflow_NonNegativeRevisionSchema = _MetaWorkflow_NonNegativeRevisionSchema;
+const _MetaWorkflow_LowercaseUuidV4Schema = z.uuidv4().lowercase();
+export const MetaWorkflow_LowercaseUuidV4Schema = _MetaWorkflow_LowercaseUuidV4Schema;
+const _MetaWorkflow_IsoDateTimeSchema = z.iso.datetime();
+export const MetaWorkflow_IsoDateTimeSchema = _MetaWorkflow_IsoDateTimeSchema;
+const _MetaWorkflow_NonNegativeFiniteNumberSchema = z
+    .number()
+    .finite()
+    .nonnegative();
+export const MetaWorkflow_NonNegativeFiniteNumberSchema = _MetaWorkflow_NonNegativeFiniteNumberSchema;
+/** Whether a sequence contains no repeated scalar value. */
+export function metaWorkflowValuesAreUnique(values) {
+    return new Set(values).size === values.length;
+}
+/**
+ * Whether homogeneous scalar values are already in canonical ascending order.
+ *
+ * Strings use deterministic UTF-16 code-unit order; numeric version arrays
+ * use numeric order so version `10` follows version `2` rather than sorting
+ * between `1` and `2`.
+ */
+/**
+ * The ONE canonical string order for every portable meta-workflow collection.
+ *
+ * It is UTF-16 code-unit order — exactly what `metaWorkflowValuesAreLexicallySorted`
+ * validates — and deliberately NOT `String.prototype.localeCompare`, whose result
+ * depends on the host ICU locale. A producer that sorts with `localeCompare` and a
+ * validator that checks code-unit order disagree for ordinary refs (`a-b` vs `a_b`,
+ * `alpha` vs `Beta`), which turns a correct value into a parse failure on one
+ * machine and a different canonical digest on another.
+ */
+export function compareMetaWorkflowCanonicalStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export function metaWorkflowValuesAreLexicallySorted(values) {
+    return values.every((value, index) => {
+        if (index === 0)
+            return true;
+        const previousValue = values[index - 1];
+        if (typeof previousValue === 'number'
+            && typeof value === 'number') {
+            return previousValue <= value;
+        }
+        const previous = String(previousValue);
+        const current = String(value);
+        // Direct ECMAScript string comparison is deterministic UTF-16 code-unit
+        // order. `localeCompare` is forbidden here because ICU/locale differences
+        // would make semantic array ordering machine-dependent.
+        return previous <= current;
+    });
+}
+//# sourceMappingURL=portable-primitives.meta-workflows.shared.schemas.js.map

package/dist/esm/flows-actors/meta-workflows/portable-primitives.meta-workflows.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-primitives.meta-workflows.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/portable-primitives.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\n\n/**\n * Internal lexical leaves shared by the portable meta-workflow contracts.\n *\n * This file intentionally owns no durable record and is not exported from the\n * package root. It IS, however, in the root barrel's transitive import closure:\n * `flows-actors/task-continuity-binding.actors.shared.schemas` needs\n * `MetaWorkflow_PositiveOrdinalSchema`. That crossing is waived at the importing\n * site and measured safe — everything published here is structural, so no\n * consumer ever needs to NAME this module. Adding a nominal type (an `enum`, a\n * `class`) would change that; see the waiver before doing so. Its purpose is to keep the exact lexical rules for digests,\n * semantic refs, UUIDs, and positive versions single-sourced without creating\n * an Action ↔ Decision ↔ Catalog dependency cycle.\n */\n\nconst _MetaWorkflow_Sha256DigestSchema = z\n  .string()\n  .regex(\n    /^sha256:[0-9a-f]{64}$/,\n    'expected `sha256:<64-hex-lowercase>`',\n  );\nexport const MetaWorkflow_Sha256DigestSchema: typeof _MetaWorkflow_Sha256DigestSchema =\n  _MetaWorkflow_Sha256DigestSchema;\n\n/**\n * Stable semantic refs have at least two namespace segments. Existing\n * methodology refs such as `top_down.market-analysis` and contract refs such\n * as `saas-specifications:MarketSnapshot` both satisfy this deliberately\n * transport-neutral grammar.\n */\nconst _MetaWorkflow_NamespacedRefSchema = z\n  .string()\n  .min(3)\n  .regex(\n    /^[A-Za-z0-9][A-Za-z0-9_-]*(?:[.:/][A-Za-z0-9][A-Za-z0-9_-]*)+$/,\n    'expected a non-empty namespaced ref',\n  );\nexport const MetaWorkflow_NamespacedRefSchema: typeof _MetaWorkflow_NamespacedRefSchema =\n  _MetaWorkflow_NamespacedRefSchema;\n\nconst _MetaWorkflow_OpaqueRefSchema = z\n  .string()\n  .min(1)\n  .refine((value) => value === value.trim(), {\n    message: 'opaque refs must not contain surrounding whitespace',\n  });\nexport const MetaWorkflow_OpaqueRefSchema: typeof _MetaWorkflow_OpaqueRefSchema =\n  _MetaWorkflow_OpaqueRefSchema;\n\nconst _MetaWorkflow_PositiveVersionSchema = z.number().int().positive();\nexport const MetaWorkflow_PositiveVersionSchema: typeof _MetaWorkflow_PositiveVersionSchema =\n  _MetaWorkflow_PositiveVersionSchema;\n\nconst _MetaWorkflow_PositiveOrdinalSchema = z.number().int().positive();\nexport const MetaWorkflow_PositiveOrdinalSchema: typeof _MetaWorkflow_PositiveOrdinalSchema =\n  _MetaWorkflow_PositiveOrdinalSchema;\n\nconst _MetaWorkflow_NonNegativeRevisionSchema = z.number().int().nonnegative();\nexport const MetaWorkflow_NonNegativeRevisionSchema: typeof _MetaWorkflow_NonNegativeRevisionSchema =\n  _MetaWorkflow_NonNegativeRevisionSchema;\n\nconst _MetaWorkflow_LowercaseUuidV4Schema = z.uuidv4().lowercase();\nexport const MetaWorkflow_LowercaseUuidV4Schema: typeof _MetaWorkflow_LowercaseUuidV4Schema =\n  _MetaWorkflow_LowercaseUuidV4Schema;\n\nconst _MetaWorkflow_IsoDateTimeSchema = z.iso.datetime();\nexport const MetaWorkflow_IsoDateTimeSchema: typeof _MetaWorkflow_IsoDateTimeSchema =\n  _MetaWorkflow_IsoDateTimeSchema;\n\nconst _MetaWorkflow_NonNegativeFiniteNumberSchema = z\n  .number()\n  .finite()\n  .nonnegative();\nexport const MetaWorkflow_NonNegativeFiniteNumberSchema: typeof _MetaWorkflow_NonNegativeFiniteNumberSchema =\n  _MetaWorkflow_NonNegativeFiniteNumberSchema;\n\n/** Whether a sequence contains no repeated scalar value. */\nexport function metaWorkflowValuesAreUnique(\n  values: ReadonlyArray<string | number>,\n): boolean {\n  return new Set(values).size === values.length;\n}\n\n/**\n * Whether homogeneous scalar values are already in canonical ascending order.\n *\n * Strings use deterministic UTF-16 code-unit order; numeric version arrays\n * use numeric order so version `10` follows version `2` rather than sorting\n * between `1` and `2`.\n */\n/**\n * The ONE canonical string order for every portable meta-workflow collection.\n *\n * It is UTF-16 code-unit order — exactly what `metaWorkflowValuesAreLexicallySorted`\n * validates — and deliberately NOT `String.prototype.localeCompare`, whose result\n * depends on the host ICU locale. A producer that sorts with `localeCompare` and a\n * validator that checks code-unit order disagree for ordinary refs (`a-b` vs `a_b`,\n * `alpha` vs `Beta`), which turns a correct value into a parse failure on one\n * machine and a different canonical digest on another.\n */\nexport function compareMetaWorkflowCanonicalStrings(left: string, right: string): number {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n\nexport function metaWorkflowValuesAreLexicallySorted(\n  values: ReadonlyArray<string | number>,\n): boolean {\n  return values.every((value, index) => {\n    if (index === 0) return true;\n    const previousValue = values[index - 1];\n    if (\n      typeof previousValue === 'number'\n      && typeof value === 'number'\n    ) {\n      return previousValue <= value;\n    }\n    const previous = String(previousValue);\n    const current = String(value);\n    // Direct ECMAScript string comparison is deterministic UTF-16 code-unit\n    // order. `localeCompare` is forbidden here because ICU/locale differences\n    // would make semantic array ordering machine-dependent.\n    return previous <= current;\n  });\n}\n"]}

package/dist/esm/flows-actors/prompt-ir.shared.schemas.d.ts

@@ -22,7 +22,7 @@ export declare enum PromptIR_ContextSourceKind {
 }
 /**
  * Unified context item for prompt compilation
- * Adapters transform existing types (RAG_RetrievalResult, Actors_Memory_Entry, etc.)
+ * Adapters transform existing types (`Actors_Memory_Entry`, `ArtifactInstance`, etc.)
  * into this common format
  */
 export declare const PromptIR_ContextItemSchema: z.ZodObject<{
@@ -33,7 +33,7 @@ export declare const PromptIR_ContextItemSchema: z.ZodObject<{
     relevance: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip, core.$ZodObjectExtra>;
+}, z.core.$strip>;
 export type PromptIR_ContextItem = z.infer<typeof PromptIR_ContextItemSchema>;
 /**
  * Compiled prompt ready for AI SDK
@@ -47,14 +47,14 @@ export declare const PromptIR_CompiledPromptSchema: z.ZodObject<{
         system: z.ZodOptional<z.ZodNumber>;
         user: z.ZodOptional<z.ZodNumber>;
         total: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$strip>>;
     metadata: z.ZodOptional<z.ZodObject<{
         agentRef: z.ZodString;
         invocationId: z.ZodOptional<z.ZodString>;
         contextItemCount: z.ZodNumber;
         curatedContextItemCount: z.ZodNumber;
         compiledAt: z.ZodString;
-    }, z.core.$strip, core.$ZodObjectExtra>>;
-}, z.core.$strip, core.$ZodObjectExtra>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type PromptIR_CompiledPrompt = z.infer<typeof PromptIR_CompiledPromptSchema>;
 //# sourceMappingURL=prompt-ir.shared.schemas.d.ts.map

package/dist/esm/flows-actors/prompt-ir.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-ir.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/flows-actors/prompt-ir.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAmBhF,OAAO,EAAE,wBAAwB,IAAI,qBAAqB,EAAE,CAAC;AAO7D;;;GAGG;AACH,oBAAY,mBAAmB;IAC7B,IAAI,SAAS,CAAQ,0CAA0C;IAC/D,MAAM,WAAW,CAAI,qDAAqD;IAC1E,GAAG,QAAQ;CACZ;AAED;;GAEG;AACH,oBAAY,0BAA0B;IACpC,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,YAAY,iBAAiB;IAC7B,UAAU,eAAe;CAC1B;AAOD;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;uCAqBrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAO9E;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;uCAyBxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}
+{"version":3,"file":"prompt-ir.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/prompt-ir.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAmBhF,OAAO,EAAE,wBAAwB,IAAI,qBAAqB,EAAE,CAAC;AAO7D;;;GAGG;AACH,oBAAY,mBAAmB;IAC7B,IAAI,SAAS,CAAQ,0CAA0C;IAC/D,MAAM,WAAW,CAAI,qDAAqD;IAC1E,GAAG,QAAQ;CACZ;AAED;;GAEG;AACH,oBAAY,0BAA0B;IACpC,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,YAAY,iBAAiB;IAC7B,UAAU,eAAe;CAC1B;AAOD;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;iBAqBrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAO9E;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;iBAyBxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/esm/flows-actors/prompt-ir.shared.schemas.js

@@ -44,7 +44,7 @@ export var PromptIR_ContextSourceKind;
 // ========================================
 /**
  * Unified context item for prompt compilation
- * Adapters transform existing types (RAG_RetrievalResult, Actors_Memory_Entry, etc.)
+ * Adapters transform existing types (`Actors_Memory_Entry`, `ArtifactInstance`, etc.)
  * into this common format
  */
 export const PromptIR_ContextItemSchema = z.object({
@@ -92,4 +92,4 @@ export const PromptIR_CompiledPromptSchema = z.object({
         compiledAt: z.string(),
     }).optional(),
 });
-//# sourceMappingURL=prompt-ir.shared.schemas.js.map
+//# sourceMappingURL=prompt-ir.shared.schemas.js.map

package/dist/esm/flows-actors/prompt-ir.shared.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-ir.shared.schemas.js","sourceRoot":"","sources":["../../../src/flows-actors/prompt-ir.shared.schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"prompt-ir.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/prompt-ir.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\";\nimport { LLMProvider_PromptFormat } from \"@wildo-ai/external-connectors-models\";\n\n//===============================================================\n// Prompt IR (Internal Representation)\n// --------\n// Minimal types for prompt compilation. Most agent/task/output\n// configuration is already in FlowsActors_Agent and related types.\n// \n// This file only contains:\n// - Trust level enum (new concept for trust boundaries)\n// - Context item schema (unified format for compiler input)\n// - Compiled prompt schema (compiler output)\n//===============================================================\n\n\n// ========================================\n// Re-export LLMProvider_PromptFormat\n// ========================================\n\nexport { LLMProvider_PromptFormat as PromptIR_PromptFormat };\n\n\n// ========================================\n// Trust Level - Core concept for trust boundaries\n// ========================================\n\n/**\n * Trust level for context items\n * Determines separation and labeling in compiled prompt\n */\nexport enum PromptIR_TrustLevel {\n  HIGH = \"high\",       // System data, verified, long-term memory\n  MEDIUM = \"medium\",   // RAG from owned docs, artifacts from previous steps\n  LOW = \"low\",         // User input, external sources\n}\n\n/**\n * Context source kind - for tracing/debugging\n */\nexport enum PromptIR_ContextSourceKind {\n  RAG = \"rag\",\n  MEMORY = \"memory\",\n  ARTIFACT = \"artifact\",\n  RELATIONSHIP = \"relationship\",\n  USER_INPUT = \"user_input\",\n}\n\n\n// ========================================\n// Context Item - Unified format for prompt injection\n// ========================================\n\n/**\n * Unified context item for prompt compilation\n * Adapters transform existing types (`Actors_Memory_Entry`, `ArtifactInstance`, etc.)\n * into this common format\n */\nexport const PromptIR_ContextItemSchema = z.object({\n  /** Unique identifier for deduplication */\n  id: z.string(),\n  \n  /** Text content to inject in prompt */\n  content: z.string(),\n  \n  /** Trust level for separation in compiled prompt */\n  trust: z.enum(PromptIR_TrustLevel),\n  \n  /** Source kind for tracing */\n  sourceKind: z.enum(PromptIR_ContextSourceKind),\n  \n  /** Relevance score 0-1, from RAG or reranker */\n  relevance: z.number().min(0).max(1).optional(),\n  \n  /** Timestamp for ordering */\n  timestamp: z.string().optional(),\n  \n  /** Additional metadata */\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\nexport type PromptIR_ContextItem = z.infer<typeof PromptIR_ContextItemSchema>;\n\n\n// ========================================\n// Compiled Prompt - Output from compiler\n// ========================================\n\n/**\n * Compiled prompt ready for AI SDK\n * Output from PromptCompilerBackendService.compile()\n */\nexport const PromptIR_CompiledPromptSchema = z.object({\n  /** System prompt (agent instructions + output contract) */\n  systemPrompt: z.string(),\n  \n  /** User prompt (task objective + context) */\n  userPrompt: z.string(),\n  \n  /** Format used for compilation */\n  format: z.string(),\n  \n  /** Token estimates for debugging */\n  tokenEstimates: z.object({\n    system: z.number().optional(),\n    user: z.number().optional(),\n    total: z.number().optional(),\n  }).optional(),\n  \n  /** Metadata for tracing */\n  metadata: z.object({\n    agentRef: z.string(),\n    invocationId: z.string().optional(),\n    contextItemCount: z.number(),\n    curatedContextItemCount: z.number(),\n    compiledAt: z.string(),\n  }).optional(),\n});\nexport type PromptIR_CompiledPrompt = z.infer<typeof PromptIR_CompiledPromptSchema>;\n"]}

package/dist/esm/flows-actors/task-continuity-binding.actors.shared.schemas.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The Actor-Task ↔ meta-workflow-continuity BOUNDARY.
+ *
+ * ## Why this module exists at the package ROOT
+ *
+ * A physical Actor Task carries the correlation identifying the semantic attempt that produced it.
+ * That makes the correlation part of the Actor Task vocabulary the package root publishes — not
+ * part of the meta-workflow AUTHORING domain published behind
+ * `@wildo-ai/saas-models/meta-workflows`.
+ *
+ * It previously lived inside that authoring domain, and the layering was therefore inverted: the
+ * root-exported `Actors_Task_Context_Schema` imported from a subpath-only module, which dragged 12
+ * of the 15 `meta-workflows/**` modules — the outbox, decision, action and execution-binding
+ * machinery — into the root barrel's transitive closure. That defeated the separation the root
+ * barrel's own comment claims to enforce, and it broke consumers outright: `bindingRole` is a
+ * nominal `enum` member, so a consumer importing `Actors_Task_Schema` from the root and deriving a
+ * schema from it emitted `TS2742` / `TS2883` — "the inferred type cannot be named". Not because the
+ * enum was unpublished: `@wildo-ai/saas-models/meta-workflows` exported it, and a consumer that also
+ * imports that subpath names it through the barrel without complaint. TypeScript only names a type
+ * through a specifier the consuming program has ALREADY RESOLVED, and a root-only consumer resolves
+ * only the root. Publication is not reachability.
+ *
+ * Dependencies run one way now: this boundary is defined here, and the continuity authoring domain
+ * imports FROM it. `meta-workflows.exports.ts` deliberately does not re-export this module; a
+ * second door onto the same room is what `pnpm check:package-entrypoints` rule 1 refuses.
+ *
+ * ## What may be added here
+ *
+ * Only what a root-exported Actor Task contract genuinely commits the root to. The remaining
+ * execution-binding vocabulary (`MetaWorkflow_ExecutionBindingStatus`, the terminal-status set,
+ * `MetaWorkflow_ExecutionCapabilityDirection`,
+ * `MetaWorkflow_ExecutionAuthorityResolutionStatus`) stays behind the subpath, because no
+ * root-exported contract references it. Widening this module re-grows the root barrel that the
+ * subpath split exists to keep small.
+ *
+ * Note the asymmetry that decides what must live here: Zod BRANDS are structural
+ * (`string & $brand<'X'>`), expressed entirely through `zod`, so a branded id can be named by any
+ * consumer without naming its defining module. An `enum` is nominal, so a root-only consumer can
+ * name it only if the ROOT's own module graph reaches its declaring file. Adding a branded id below
+ * is therefore not required by type-naming; adding an enum referenced by a root contract is.
+ *
+ * ## The residual crossing, and why it is safe
+ *
+ * entrypoint-closure-waiver: this module imports two `meta-workflows/**` leaves that only the
+ * subpath publishes — `continuity-identifiers` and `portable-primitives`. Both were MEASURED to
+ * publish nothing but STRUCTURAL types: Zod brands are `string & $brand<'X'>`, which any consumer
+ * can write without naming the defining module, so no `TS2742`/`TS2883` is reachable through them.
+ * Verified by a root-only consumer that derives from `Actors_Task_Schema` and compiles with
+ * `declaration: true`; its emitted `.d.ts` names `import("@wildo-ai/saas-models")`, never a
+ * `node_modules/.../dist/esm/...` path.
+ *
+ * Publishing those two leaves at the root instead would move the entire portable primitive
+ * vocabulary into the root barrel — contradicting `portable-primitives`' own stated design and
+ * re-growing exactly what the subpath split exists to shrink.
+ *
+ * **This waiver rests on that measurement, not on a category.** It was stress-tested: injecting a
+ * nominal `enum` into `continuity-identifiers` and referencing it from the root-exported contract
+ * brings `TS2742` straight back. So if either leaf gains a nominal type a root-exported contract
+ * references, the crossing stops being safe and that member belongs in THIS module, beside the role
+ * enum. Re-run the probe rather than reasoning from the type's kind.
+ *
+ * @see `.claude/rules/package-public-entrypoints.md`
+ */
+/**
+ * Semantic role of one stored Execution Binding variant.
+ *
+ * Promotion effects use the Driver envelope directly and deliberately do not
+ * become a third Treatment-attempt role.
+ *
+ * Published at the root because it appears on `Actors_Task_Context.continuityBinding`; the rest of
+ * the execution-binding vocabulary remains in
+ * `meta-workflows/execution-binding-vocabularies.meta-workflows.shared.schemas`.
+ *
+ * @example
+ * import { MetaWorkflow_ExecutionBindingRole } from '@wildo-ai/saas-models';
+ */
+export declare enum MetaWorkflow_ExecutionBindingRole {
+    ACTION = "ACTION",
+    EVALUATOR = "EVALUATOR"
+}
+//# sourceMappingURL=task-continuity-binding.actors.shared.schemas.d.ts.map

package/dist/esm/flows-actors/task-continuity-binding.actors.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-continuity-binding.actors.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/task-continuity-binding.actors.shared.schemas.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;GAYG;AACH,oBAAY,iCAAiC;IAC3C,MAAM,WAAW;IACjB,SAAS,cAAc;CACxB"}

package/dist/esm/flows-actors/task-continuity-binding.actors.shared.schemas.js

@@ -0,0 +1,82 @@
+/**
+ * The Actor-Task ↔ meta-workflow-continuity BOUNDARY.
+ *
+ * ## Why this module exists at the package ROOT
+ *
+ * A physical Actor Task carries the correlation identifying the semantic attempt that produced it.
+ * That makes the correlation part of the Actor Task vocabulary the package root publishes — not
+ * part of the meta-workflow AUTHORING domain published behind
+ * `@wildo-ai/saas-models/meta-workflows`.
+ *
+ * It previously lived inside that authoring domain, and the layering was therefore inverted: the
+ * root-exported `Actors_Task_Context_Schema` imported from a subpath-only module, which dragged 12
+ * of the 15 `meta-workflows/**` modules — the outbox, decision, action and execution-binding
+ * machinery — into the root barrel's transitive closure. That defeated the separation the root
+ * barrel's own comment claims to enforce, and it broke consumers outright: `bindingRole` is a
+ * nominal `enum` member, so a consumer importing `Actors_Task_Schema` from the root and deriving a
+ * schema from it emitted `TS2742` / `TS2883` — "the inferred type cannot be named". Not because the
+ * enum was unpublished: `@wildo-ai/saas-models/meta-workflows` exported it, and a consumer that also
+ * imports that subpath names it through the barrel without complaint. TypeScript only names a type
+ * through a specifier the consuming program has ALREADY RESOLVED, and a root-only consumer resolves
+ * only the root. Publication is not reachability.
+ *
+ * Dependencies run one way now: this boundary is defined here, and the continuity authoring domain
+ * imports FROM it. `meta-workflows.exports.ts` deliberately does not re-export this module; a
+ * second door onto the same room is what `pnpm check:package-entrypoints` rule 1 refuses.
+ *
+ * ## What may be added here
+ *
+ * Only what a root-exported Actor Task contract genuinely commits the root to. The remaining
+ * execution-binding vocabulary (`MetaWorkflow_ExecutionBindingStatus`, the terminal-status set,
+ * `MetaWorkflow_ExecutionCapabilityDirection`,
+ * `MetaWorkflow_ExecutionAuthorityResolutionStatus`) stays behind the subpath, because no
+ * root-exported contract references it. Widening this module re-grows the root barrel that the
+ * subpath split exists to keep small.
+ *
+ * Note the asymmetry that decides what must live here: Zod BRANDS are structural
+ * (`string & $brand<'X'>`), expressed entirely through `zod`, so a branded id can be named by any
+ * consumer without naming its defining module. An `enum` is nominal, so a root-only consumer can
+ * name it only if the ROOT's own module graph reaches its declaring file. Adding a branded id below
+ * is therefore not required by type-naming; adding an enum referenced by a root contract is.
+ *
+ * ## The residual crossing, and why it is safe
+ *
+ * entrypoint-closure-waiver: this module imports two `meta-workflows/**` leaves that only the
+ * subpath publishes — `continuity-identifiers` and `portable-primitives`. Both were MEASURED to
+ * publish nothing but STRUCTURAL types: Zod brands are `string & $brand<'X'>`, which any consumer
+ * can write without naming the defining module, so no `TS2742`/`TS2883` is reachable through them.
+ * Verified by a root-only consumer that derives from `Actors_Task_Schema` and compiles with
+ * `declaration: true`; its emitted `.d.ts` names `import("@wildo-ai/saas-models")`, never a
+ * `node_modules/.../dist/esm/...` path.
+ *
+ * Publishing those two leaves at the root instead would move the entire portable primitive
+ * vocabulary into the root barrel — contradicting `portable-primitives`' own stated design and
+ * re-growing exactly what the subpath split exists to shrink.
+ *
+ * **This waiver rests on that measurement, not on a category.** It was stress-tested: injecting a
+ * nominal `enum` into `continuity-identifiers` and referencing it from the root-exported contract
+ * brings `TS2742` straight back. So if either leaf gains a nominal type a root-exported contract
+ * references, the crossing stops being safe and that member belongs in THIS module, beside the role
+ * enum. Re-run the probe rather than reasoning from the type's kind.
+ *
+ * @see `.claude/rules/package-public-entrypoints.md`
+ */
+/**
+ * Semantic role of one stored Execution Binding variant.
+ *
+ * Promotion effects use the Driver envelope directly and deliberately do not
+ * become a third Treatment-attempt role.
+ *
+ * Published at the root because it appears on `Actors_Task_Context.continuityBinding`; the rest of
+ * the execution-binding vocabulary remains in
+ * `meta-workflows/execution-binding-vocabularies.meta-workflows.shared.schemas`.
+ *
+ * @example
+ * import { MetaWorkflow_ExecutionBindingRole } from '@wildo-ai/saas-models';
+ */
+export var MetaWorkflow_ExecutionBindingRole;
+(function (MetaWorkflow_ExecutionBindingRole) {
+    MetaWorkflow_ExecutionBindingRole["ACTION"] = "ACTION";
+    MetaWorkflow_ExecutionBindingRole["EVALUATOR"] = "EVALUATOR";
+})(MetaWorkflow_ExecutionBindingRole || (MetaWorkflow_ExecutionBindingRole = {}));
+//# sourceMappingURL=task-continuity-binding.actors.shared.schemas.js.map

package/dist/esm/flows-actors/task-continuity-binding.actors.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-continuity-binding.actors.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/task-continuity-binding.actors.shared.schemas.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAN,IAAY,iCAGX;AAHD,WAAY,iCAAiC;IAC3C,sDAAiB,CAAA;IACjB,4DAAuB,CAAA;AACzB,CAAC,EAHW,iCAAiC,KAAjC,iCAAiC,QAG5C","sourcesContent":["import { z } from \"zod\";\n\nimport {\n  ContinuityAuthorityDomainIdSchema,\n  ContinuitySubjectIdSchema,\n  ContinuumIdSchema,\n  ExecutionBindingIdSchema,\n  TreatmentIdSchema,\n  WorkCycleIdSchema,\n} from \"./meta-workflows/continuity-identifiers.meta-workflows.shared.schemas\";\nimport { MetaWorkflow_PositiveOrdinalSchema } from \"./meta-workflows/portable-primitives.meta-workflows.shared.schemas\";\n\n/**\n * The Actor-Task ↔ meta-workflow-continuity BOUNDARY.\n *\n * ## Why this module exists at the package ROOT\n *\n * A physical Actor Task carries the correlation identifying the semantic attempt that produced it.\n * That makes the correlation part of the Actor Task vocabulary the package root publishes — not\n * part of the meta-workflow AUTHORING domain published behind\n * `@wildo-ai/saas-models/meta-workflows`.\n *\n * It previously lived inside that authoring domain, and the layering was therefore inverted: the\n * root-exported `Actors_Task_Context_Schema` imported from a subpath-only module, which dragged 12\n * of the 15 `meta-workflows/**` modules — the outbox, decision, action and execution-binding\n * machinery — into the root barrel's transitive closure. That defeated the separation the root\n * barrel's own comment claims to enforce, and it broke consumers outright: `bindingRole` is a\n * nominal `enum` member, so a consumer importing `Actors_Task_Schema` from the root and deriving a\n * schema from it emitted `TS2742` / `TS2883` — \"the inferred type cannot be named\". Not because the\n * enum was unpublished: `@wildo-ai/saas-models/meta-workflows` exported it, and a consumer that also\n * imports that subpath names it through the barrel without complaint. TypeScript only names a type\n * through a specifier the consuming program has ALREADY RESOLVED, and a root-only consumer resolves\n * only the root. Publication is not reachability.\n *\n * Dependencies run one way now: this boundary is defined here, and the continuity authoring domain\n * imports FROM it. `meta-workflows.exports.ts` deliberately does not re-export this module; a\n * second door onto the same room is what `pnpm check:package-entrypoints` rule 1 refuses.\n *\n * ## What may be added here\n *\n * Only what a root-exported Actor Task contract genuinely commits the root to. The remaining\n * execution-binding vocabulary (`MetaWorkflow_ExecutionBindingStatus`, the terminal-status set,\n * `MetaWorkflow_ExecutionCapabilityDirection`,\n * `MetaWorkflow_ExecutionAuthorityResolutionStatus`) stays behind the subpath, because no\n * root-exported contract references it. Widening this module re-grows the root barrel that the\n * subpath split exists to keep small.\n *\n * Note the asymmetry that decides what must live here: Zod BRANDS are structural\n * (`string & $brand<'X'>`), expressed entirely through `zod`, so a branded id can be named by any\n * consumer without naming its defining module. An `enum` is nominal, so a root-only consumer can\n * name it only if the ROOT's own module graph reaches its declaring file. Adding a branded id below\n * is therefore not required by type-naming; adding an enum referenced by a root contract is.\n *\n * ## The residual crossing, and why it is safe\n *\n * entrypoint-closure-waiver: this module imports two `meta-workflows/**` leaves that only the\n * subpath publishes — `continuity-identifiers` and `portable-primitives`. Both were MEASURED to\n * publish nothing but STRUCTURAL types: Zod brands are `string & $brand<'X'>`, which any consumer\n * can write without naming the defining module, so no `TS2742`/`TS2883` is reachable through them.\n * Verified by a root-only consumer that derives from `Actors_Task_Schema` and compiles with\n * `declaration: true`; its emitted `.d.ts` names `import(\"@wildo-ai/saas-models\")`, never a\n * `node_modules/.../dist/esm/...` path.\n *\n * Publishing those two leaves at the root instead would move the entire portable primitive\n * vocabulary into the root barrel — contradicting `portable-primitives`' own stated design and\n * re-growing exactly what the subpath split exists to shrink.\n *\n * **This waiver rests on that measurement, not on a category.** It was stress-tested: injecting a\n * nominal `enum` into `continuity-identifiers` and referencing it from the root-exported contract\n * brings `TS2742` straight back. So if either leaf gains a nominal type a root-exported contract\n * references, the crossing stops being safe and that member belongs in THIS module, beside the role\n * enum. Re-run the probe rather than reasoning from the type's kind.\n *\n * @see `.claude/rules/package-public-entrypoints.md`\n */\n\n/**\n * Semantic role of one stored Execution Binding variant.\n *\n * Promotion effects use the Driver envelope directly and deliberately do not\n * become a third Treatment-attempt role.\n *\n * Published at the root because it appears on `Actors_Task_Context.continuityBinding`; the rest of\n * the execution-binding vocabulary remains in\n * `meta-workflows/execution-binding-vocabularies.meta-workflows.shared.schemas`.\n *\n * @example\n * import { MetaWorkflow_ExecutionBindingRole } from '@wildo-ai/saas-models';\n */\nexport enum MetaWorkflow_ExecutionBindingRole {\n  ACTION = 'ACTION',\n  EVALUATOR = 'EVALUATOR',\n}\n\n"]}