@wildo-ai/saas-models 1.1.4 → 1.1.5

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

@@ -1 +0,0 @@
-{"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/task-continuity-binding.actors.shared.schemas.d.ts

@@ -1,81 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,82 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"]}

package/dist/esm/flows-actors/utils/flow-actors.context-builder.apps-context.shared.utils.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=flow-actors.context-builder.apps-context.shared.utils.d.ts.map

package/dist/esm/flows-actors/utils/flow-actors.context-builder.apps-context.shared.utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flow-actors.context-builder.apps-context.shared.utils.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/utils/flow-actors.context-builder.apps-context.shared.utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC"}

package/dist/esm/flows-actors/utils/flow-actors.context-builder.apps-context.shared.utils.js

@@ -1 +0,0 @@
-//# sourceMappingURL=flow-actors.context-builder.apps-context.shared.utils.js.map

package/dist/esm/flows-actors/utils/flow-actors.context-builder.apps-context.shared.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flow-actors.context-builder.apps-context.shared.utils.js","sourceRoot":"","sources":["../../../../../src/flows-actors/utils/flow-actors.context-builder.apps-context.shared.utils.ts"],"names":[],"mappings":"","sourcesContent":["\n\nexport {};\n"]}