npm - @sanity/workflow-engine - Versions diffs - 0.3.0 → 0.5.0 - Mend

@sanity/workflow-engine 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/_chunks-cjs/schema.cjs +291 -317
package/dist/_chunks-cjs/schema.cjs.map +1 -1
package/dist/_chunks-es/schema.js +291 -317
package/dist/_chunks-es/schema.js.map +1 -1
package/dist/define.cjs +480 -74
package/dist/define.cjs.map +1 -1
package/dist/define.d.cts +7404 -4450
package/dist/define.d.ts +7404 -4450
package/dist/define.js +482 -76
package/dist/define.js.map +1 -1
package/dist/index.cjs +1986 -1604
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +10627 -5009
package/dist/index.d.ts +10627 -5009
package/dist/index.js +1987 -1605
package/dist/index.js.map +1 -1
package/package.json +1 -1

package/dist/_chunks-es/schema.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schema.js","sources":["../../src/types/enums.ts","../../src/define/schema.ts"],"sourcesContent":["/*\n Leaf enums — the const arrays (and their derived union types) that both\n * the authoring schema and the engine address by name.\n \n This module imports nothing. It is the schema-free foundation that\n * `../define/schema.ts` reads its value constants from, which is what keeps\n * the type model and the valibot schema free of an import cycle: the value edge\n * `schema.ts → enums.ts` terminates here.\n /\n\n// Task status — used by instance state. Authoring code references this\n// via `Action.setStatus`, which the valibot schema constrains to the\n// terminal subset.\nexport const TASK_STATUSES = ['pending', 'active', 'done', 'skipped', 'failed'] as const\nexport type TaskStatus = (typeof TASK_STATUSES)[number]\n\n// The three state scopes a slot can live in. Authoring (`ScopeKey`,\n// `stateRead` sources) and the engine both address slots by scope.\nexport const STATE_SCOPES = ['workflow', 'stage', 'task'] as const\nexport type StateScope = (typeof STATE_SCOPES)[number]\n\n// Document-value permissions. Grants (`Grant` in ./authorization.ts) compose\n// most-permissive-wins.\nexport const DOCUMENT_VALUE_PERMISSIONS = ['create', 'read', 'update'] as const\nexport type DocumentValuePermission = (typeof DOCUMENT_VALUE_PERMISSIONS)[number]\n\n// Mutation-guard actions — the lake operations a guard can gate. See the\n// guard types in ./authorization.ts.\nexport const MUTATION_GUARD_ACTIONS = [\n 'create',\n 'update',\n 'delete',\n 'publish',\n 'unpublish',\n] as const\nexport type MutationGuardAction = (typeof MUTATION_GUARD_ACTIONS)[number]\n","/\n Valibot schemas for the workflow authoring surface — the things a workflow\n * author writes by hand and feeds to `defineWorkflow`. Types in this\n * file are the canonical authoring types: they are inferred from\n * the schemas, so the runtime schema and the compile-time type cannot\n * drift.\n \n Engine-produced shapes (`WorkflowInstance`, `TaskStatusEntry`,\n * `HistoryEntry`, etc.) stay as plain TS interfaces in `../types.ts` —\n * those are outputs, not inputs.\n \n Strictness: every object schema is `v.strictObject` so unknown keys\n * produce a parse error. That catches typos like `verison: 1` instead\n * of `version: 1` at deploy time, with the path pointing exactly at\n * the offender.\n /\n\nimport as v from 'valibot'\n\nimport {\n DOCUMENT_VALUE_PERMISSIONS,\n MUTATION_GUARD_ACTIONS,\n STATE_SCOPES,\n TASK_STATUSES,\n type StateScope,\n} from '../types/enums.ts'\n\nconst NonEmpty = v.pipe(v.string(), v.minLength(1, 'must be a non-empty string'))\n\nconst PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1))\n\n/*\n Picklist with a zod-compatible \"Invalid option\" message that lists every\n * allowed value, so a typo'd discriminator or enum lands with a message an\n * author can act on (e.g. `Invalid option: expected one of \"done\"\|\"skipped\"`).\n /\nfunction picklist<const TOptions extends readonly [string, ...string[]]>(options: TOptions) {\n return v.picklist(\n options,\n `Invalid option: expected one of ${options.map((o) => `\"${o}\"`).join('\|')}`,\n )\n}\n\n/\n GDR (Global Document Reference) — see `../refs.ts`. URI form\n * `<scheme>:<...id-parts>`, e.g. `dataset:proj:ds:doc` or\n * `canvas:resourceId:doc`. Every cross-doc reference in the engine API\n * uses this shape.\n /\nconst GdrSchema = v.strictObject({\n id: v.pipe(\n v.string(),\n v.regex(\n /^(dataset\|canvas\|media-library\|dashboard):/,\n \"must be a GDR URI of form '<scheme>:<...id-parts>' where scheme is one of: dataset, canvas, media-library, dashboard\",\n ),\n ),\n type: NonEmpty,\n})\n\n// Source — typed binding union. Op fields and effect bindings resolve\n// concrete values through this discriminated union; no GROQ in the binding\n// language. Anywhere a concrete value is needed at commit time, the engine\n// resolves a Source.\n\ntype SourceInternal =\n \| {source: 'literal'; value: string \| number \| boolean \| null}\n \| {source: 'param'; paramId: string}\n \| {source: 'actor'}\n \| {source: 'now'}\n \| {source: 'self'}\n \| {source: 'stageId'}\n \| {\n source: 'stateRead'\n scope: StateScope\n slotId: string\n path?: string \| undefined\n }\n \| {source: 'effectOutput'; contextId: string; path?: string \| undefined}\n /\n Spawn-only sources. Resolved at spawn-time inside `Spawn.forEach.as`\n * projection. `row` reads from the current iteration row (the GROQ\n * result item). `parentState` reads from the spawning parent's\n * resolved workflow-scope state — the slot envelope as on the\n * parent (`{ id, _type, value, ... }`), with an optional path dive.\n /\n \| {source: 'row'; path?: string \| undefined}\n \| {source: 'parentState'; slotId: string; path?: string \| undefined}\n \| {source: 'object'; fields: Record<string, SourceInternal>}\n\nconst SourceSchema: v.GenericSchema<SourceInternal> = v.lazy(() =>\n v.union([\n v.strictObject({\n source: v.literal('literal'),\n value: v.union([v.string(), v.number(), v.boolean(), v.null()]),\n }),\n v.strictObject({source: v.literal('param'), paramId: NonEmpty}),\n v.strictObject({source: v.literal('actor')}),\n v.strictObject({source: v.literal('now')}),\n v.strictObject({source: v.literal('self')}),\n v.strictObject({source: v.literal('stageId')}),\n v.strictObject({\n source: v.literal('stateRead'),\n scope: picklist(STATE_SCOPES),\n slotId: NonEmpty,\n path: v.optional(v.string()),\n }),\n // effectsContext lookup — reads from `instance.effectsContext[id === ID].value`.\n // Used by chained effects where one handler's output feeds another's binding.\n v.strictObject({\n source: v.literal('effectOutput'),\n contextId: NonEmpty,\n path: v.optional(v.string()),\n }),\n v.strictObject({source: v.literal('row'), path: v.optional(v.string())}),\n v.strictObject({\n source: v.literal('parentState'),\n slotId: NonEmpty,\n path: v.optional(v.string()),\n }),\n // Compound object source — resolves each field's Source recursively\n // and packages the result into a JSON object. Lets ops append rich\n // rows to `checklist` / `notes` / `assignees` slots, e.g.\n // `{ source: \"object\", fields: { signer: { source: \"actor\" },\n // at: { source: \"now\" } } }`.\n v.strictObject({\n source: v.literal('object'),\n fields: v.record(NonEmpty, SourceSchema),\n }),\n ]),\n)\nexport type Source = SourceInternal\n\n// ScopeKey — { scope, key } addressing a state slot in one of the three\n// state scopes (workflow, stage, task).\n\nconst ScopeKeySchema = v.strictObject({\n scope: picklist(STATE_SCOPES),\n slotId: NonEmpty,\n})\nexport type ScopeKey = v.InferOutput<typeof ScopeKeySchema>\n\n// Op predicates — small typed predicate for op.state.updateWhere /\n// op.state.removeWhere. Separate from filter GROQ.\n\ntype OpPredicateInternal =\n \| {field: string; equals: Source}\n \| {all: OpPredicateInternal[]}\n \| {any: OpPredicateInternal[]}\n\nconst OpPredicateSchema: v.GenericSchema<OpPredicateInternal> = v.lazy(() =>\n v.union([\n v.strictObject({\n field: NonEmpty,\n equals: SourceSchema,\n }),\n v.strictObject({all: v.array(OpPredicateSchema)}),\n v.strictObject({any: v.array(OpPredicateSchema)}),\n ]),\n)\nexport type OpPredicate = OpPredicateInternal\n\n// Ops — workflow.op. primitives that run inline during an action commit.\n// Each op type has structured fields, NOT a GROQ binding language.\n\nconst OpSchema = v.variant('type', [\n v.strictObject({\n type: v.literal('workflow.op.state.set'),\n target: ScopeKeySchema,\n value: SourceSchema,\n }),\n v.strictObject({\n type: v.literal('workflow.op.state.append'),\n target: ScopeKeySchema,\n item: SourceSchema,\n }),\n v.strictObject({\n type: v.literal('workflow.op.state.updateWhere'),\n target: ScopeKeySchema,\n where: OpPredicateSchema,\n merge: v.record(NonEmpty, SourceSchema),\n }),\n v.strictObject({\n type: v.literal('workflow.op.state.removeWhere'),\n target: ScopeKeySchema,\n where: OpPredicateSchema,\n }),\n v.strictObject({\n type: v.literal('workflow.op.status.set'),\n taskId: NonEmpty,\n status: picklist(TASK_STATUSES),\n }),\n])\nexport type Op = v.InferOutput<typeof OpSchema>\n\n// State slots — each declares its `source.kind` (init / query / write /\n// literal / stateRead). Authoring shape only; engine resolves slots into\n// `ResolvedStateSlot` at runtime (types.ts).\n\nconst StateSlotSourceSchema = v.union([\n v.strictObject({kind: v.literal('init')}),\n v.strictObject({\n kind: v.literal('query'),\n query: NonEmpty,\n resource: v.optional(v.union([v.literal('workflow'), v.literal('subject'), GdrSchema])),\n }),\n v.strictObject({kind: v.literal('write')}),\n /*\n Pre-populate the slot at resolution time with a constant value.\n * Useful for stage- or task-scope slots that should start non-empty\n * (e.g. a default headline, a starting tally).\n /\n v.strictObject({kind: v.literal('literal'), value: v.unknown()}),\n /\n Pre-populate by reading another already-resolved slot. `scope:\n * \"workflow\"` reads from the workflow-scope `state[]` (resolved at\n * startInstance). `scope: \"stage\"` reads from an earlier slot in\n * this same stage entry's `state[]` (sequential resolution).\n * Optional `path` selects a nested field (e.g. `path: \"id\"` on a\n * doc.ref slot).\n /\n v.strictObject({\n kind: v.literal('stateRead'),\n scope: v.union([v.literal('workflow'), v.literal('stage')]),\n slotId: NonEmpty,\n path: v.optional(v.string()),\n }),\n])\nexport type StateSlotSource = v.InferOutput<typeof StateSlotSourceSchema>\n\n/\n Canonical set of state-slot kinds — the discriminator for both\n * authored {@link StateSlot}s and runtime `StateSlotValueMap`. Spawn\n * projections reuse it so a typo'd slot type is rejected at deploy\n * rather than silently dropped at projection time.\n /\nconst StateSlotKindSchema = picklist([\n 'workflow.state.doc.ref',\n 'workflow.state.doc.refs',\n // Release reference. A workflow declares this slot to say \"I target a\n // Content Release\"; the runtime fills it with a specific release at\n // start time, and the engine auto-derives the instance's read\n // perspective from it.\n 'workflow.state.release.ref',\n 'workflow.state.query',\n 'workflow.state.value.string',\n 'workflow.state.value.url',\n 'workflow.state.value.number',\n 'workflow.state.value.boolean',\n 'workflow.state.value.dateTime',\n 'workflow.state.value.actor',\n 'workflow.state.checklist',\n 'workflow.state.notes',\n 'workflow.state.assignees',\n])\n\n// Every kind shares one shape — only the `type` discriminator differs —\n// so a single object keyed by the kind picklist expresses the slot\n// exactly, and a typo'd `type` is rejected with an \"Invalid option\" path.\nconst StateSlotSchema = v.strictObject({\n type: StateSlotKindSchema,\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n source: StateSlotSourceSchema,\n})\nexport type StateSlot = v.InferOutput<typeof StateSlotSchema>\n\n// Filters & predicates\n\nexport const FilterSchema = v.union([\n // Inline GROQ — only reserved params allowed at runtime.\n NonEmpty,\n // Reference to a named predicate, optionally with named args.\n v.strictObject({\n ref: NonEmpty,\n args: v.optional(v.record(v.string(), v.unknown())),\n }),\n])\nexport type Filter = v.InferOutput<typeof FilterSchema>\n\nconst PredicateParamSchema = v.strictObject({\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n type: picklist(['string', 'number', 'boolean', 'string[]', 'reference']),\n enum: v.optional(v.array(v.string())),\n})\nexport type PredicateParam = v.InferOutput<typeof PredicateParamSchema>\n\nexport const PredicateSchema = v.strictObject({\n type: v.optional(v.literal('workflow.predicate')),\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n groq: NonEmpty,\n params: v.optional(v.array(PredicateParamSchema)),\n})\nexport type Predicate = v.InferOutput<typeof PredicateSchema>\n\n// Effects\n\nexport const EffectSchema = v.strictObject({\n type: v.optional(v.literal('workflow.effect')),\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n // Bindings resolve typed Source values at commit time, producing\n // concrete JSON in the queued effect's `params`. NO GROQ.\n bindings: v.optional(v.record(v.string(), SourceSchema)),\n input: v.optional(v.record(v.string(), v.unknown())),\n})\nexport type Effect = v.InferOutput<typeof EffectSchema>\n\n// Actions\n\nconst TerminalTaskStatus = picklist(['done', 'skipped', 'failed'])\n\nconst PermissionSchema = picklist(DOCUMENT_VALUE_PERMISSIONS)\n\n/\n Caller-supplied params declared on an action. The engine validates\n * incoming `params` against this list before running ops or queuing\n * effects: missing required params → ActionParamsInvalidError, action\n * does not commit. Resolved values feed `Source.param` lookups.\n /\nconst ActionParamSchema = v.strictObject({\n type: v.optional(v.literal('workflow.action.param')),\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n paramType: picklist([\n 'string',\n 'number',\n 'boolean',\n 'url',\n 'dateTime',\n 'actor',\n 'doc.ref',\n 'doc.refs',\n 'json',\n ]),\n required: v.optional(v.boolean()),\n})\nexport type ActionParam = v.InferOutput<typeof ActionParamSchema>\n\nexport const ActionSchema = v.strictObject({\n type: v.optional(v.literal('workflow.action')),\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n filter: v.optional(FilterSchema),\n /* Caller-supplied params, validated before ops/effects run. /\n params: v.optional(v.array(ActionParamSchema)),\n /\n Status the task flips to when this action fires. Omit to leave\n * the task status unchanged — used by intermediate `claim` /\n * `assign` / partial-update actions where the task should stay\n * active so a later action can fire on it. Declared values must\n * be terminal (`done` / `skipped` / `failed`); the engine never\n * mid-flip back to `active` outside of the `workflow.op.status.set`\n * op explicit path.\n /\n setStatus: v.optional(TerminalTaskStatus),\n /\n Inline state-mutation primitives executed during the action commit.\n * Each op runs against the in-memory mutation (deterministic, no\n * external I/O). Resolved Sources turn into concrete JSON before the\n * op applies. Logged on `history[]` as `workflow.history.opApplied`\n * and surfaced on the `ActionResult.ranOps`.\n /\n ops: v.optional(v.array(OpSchema)),\n effects: v.optional(v.array(EffectSchema)),\n /\n Role gating — OR-match against `Actor.roles[]`. If omitted, no role\n * gate. `\"\"` in Actor.roles always matches (bench / all-access).\n /\n roles: v.optional(v.array(NonEmpty)),\n /*\n When true, the actor must appear in the task's `assignees[]` (as a\n * user-kind assignee matching by id) for the action to be allowed.\n /\n requireAssignment: v.optional(v.boolean()),\n /\n Which permission on the workflow.instance document the actor must\n * hold (per supplied `grants`). Defaults to \"update\". Only checked\n * when grants are supplied at evaluate/fireAction time.\n /\n requiredPermission: v.optional(PermissionSchema),\n})\nexport type Action = v.InferOutput<typeof ActionSchema>\n\n// Spawn (nested workflows)\n\nconst CompletionPolicySchema = v.union([\n v.strictObject({kind: v.literal('all')}),\n v.strictObject({kind: v.literal('any')}),\n v.strictObject({\n kind: v.literal('count'),\n n: PositiveInt,\n }),\n])\n\n/\n Logical reference to a deployed workflow definition. The engine\n * resolves it at spawn time by querying its own workflow resource for\n * a matching (workflowId, tags ∩ engine.tags, version) tuple, ordering\n * by `version desc` and picking the first — or the matching `version`\n * if explicitly specified.\n \n Authors never have a stable GDR URI to reference (tags can be\n * renamed, workflows redeployed). They have the stable contract: the\n * `workflowId`.\n /\nconst LogicalDefinitionRefSchema = v.strictObject({\n workflowId: NonEmpty,\n version: v.optional(v.union([PositiveInt, v.literal('latest')])),\n})\n\n/\n `forEach` — spawn fan-out projection.\n \n - `groq` runs against the lake (paramsForLake-stripped reserved\n * params: `$self`, `$state`, `$parent`, `$ancestors`, `$stage`,\n * `$now`). Result is an array; engine creates one child per row.\n * - `as.initialState` is a typed projection from each row to the\n * child's initial state slots. Values use the `Source` union with\n * two spawn-only variants:\n * - `{ source: \"row\", path? }` — pull from the current row.\n * - `{ source: \"parentState\", slotId, path? }` — pull from the\n * spawning parent's resolved workflow-scope state.\n * - `as.effectsContext` optionally seeds the child's effectsContext.\n \n The spawn does not auto-stamp anything onto the child. Whatever\n * slots the child needs, the author must declare on the child's\n * workflow definition AND project from each row via `as.initialState`.\n /\nconst SpawnForEachSchema = v.strictObject({\n groq: NonEmpty,\n as: v.strictObject({\n initialState: v.optional(\n v.array(\n v.strictObject({\n type: StateSlotKindSchema,\n id: NonEmpty,\n value: SourceSchema,\n }),\n ),\n ),\n effectsContext: v.optional(v.record(v.string(), SourceSchema)),\n }),\n})\n\nconst SpawnSchema = v.strictObject({\n type: v.optional(v.literal('workflow.spawn')),\n id: v.optional(v.string()),\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n definitionRef: LogicalDefinitionRefSchema,\n forEach: SpawnForEachSchema,\n completionPolicy: v.optional(CompletionPolicySchema),\n})\nexport type Spawn = v.InferOutput<typeof SpawnSchema>\n\n// Assignees — typed. `kind: \"user\"` matches `Actor.id`; `kind: \"role\"`\n// matches if `Actor.roles[]` contains the role string.\n\nexport const AssigneeSchema = v.variant('kind', [\n v.strictObject({kind: v.literal('user'), id: NonEmpty}),\n v.strictObject({kind: v.literal('role'), role: NonEmpty}),\n])\nexport type Assignee = v.InferOutput<typeof AssigneeSchema>\n\n// Tasks\n\nexport const TaskSchema = v.strictObject({\n type: v.optional(v.literal('workflow.task')),\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n assignees: v.optional(v.array(AssigneeSchema)),\n filter: v.optional(FilterSchema),\n invokeOn: v.optional(picklist(['stageEnter', 'manual'])),\n /\n Auto-completion predicate — same shape as `transition.filter`. When\n * truthy at activation or on any subsequent cascade, the engine\n * flips the task to `done` with a `{ kind: \"system\", id: \"engine.completeWhen\" }`\n * actor. A full filter, not just a wall-clock deadline.\n /\n completeWhen: v.optional(FilterSchema),\n /\n Auto-failure predicate — symmetric to `completeWhen`. Same shape,\n * same evaluation cadence (activation + every cascade), but flips\n * the task to `failed` (not `done`) with a `{ kind: \"system\",\n * id: \"engine.failWhen\" }` actor. When both `completeWhen` and\n * `failWhen` resolve truthy on the same evaluation, `failWhen`\n * wins — failure is the more notable signal and should not be\n * silently swallowed.\n /\n failWhen: v.optional(FilterSchema),\n effects: v.optional(v.array(EffectSchema)),\n actions: v.optional(v.array(ActionSchema)),\n spawns: v.optional(SpawnSchema),\n contentRefs: v.optional(v.array(v.unknown())),\n /* Task-scoped state slots. Resolved at task activation time. /\n state: v.optional(v.array(StateSlotSchema)),\n})\nexport type Task = v.InferOutput<typeof TaskSchema>\n\n// Transitions\n\nexport const TransitionSchema = v.strictObject({\n type: v.optional(v.literal('workflow.transition')),\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n to: NonEmpty,\n on: v.optional(v.string()),\n filter: v.optional(FilterSchema),\n effects: v.optional(v.array(EffectSchema)),\n})\nexport type Transition = v.InferOutput<typeof TransitionSchema>\n\n// Guards — lake mutation guards (Content Lake). DISTINCT from `Filter`\n// above: a `Filter` is the engine's in-memory soft predicate that gates\n// transitions/tasks/actions; a `Guard` compiles to a `temp.system.guard`\n// document the lake evaluates at mutation time and that fails closed.\n//\n// The authoring shape is match + predicate + metadata. Targets in\n// `match.idRefs` are `Source`s resolved at deploy — `{source:\"self\"}`\n// targets the workflow instance; a `stateRead` of a doc-ref slot targets that\n// doc. The engine resolves each Source to a GDR, then splits it into the guard's\n// resource (resourceType/resourceId — the engine's outer-layer encapsulation;\n// the content lake is per-datasource) plus a BARE id. A GDR never appears in\n// `predicate`. All idRefs of one guard must resolve to the same resource (a\n// guard is single-resource).\n\nconst GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS)\nexport type GuardAction = v.InferOutput<typeof GuardActionSchema>\n\nconst GuardMatchSchema = v.strictObject({\n /* Subject `_type`(s); empty matches any type. /\n types: v.optional(v.array(NonEmpty)),\n /* Target docs as `Source`s resolved at deploy to bare ids + the resource. /\n idRefs: v.optional(v.array(SourceSchema)),\n /* Glob id patterns (bare, resource-local). /\n idPatterns: v.optional(v.array(NonEmpty)),\n actions: v.pipe(\n v.array(GuardActionSchema),\n v.minLength(1, 'a guard must match at least one action'),\n ),\n})\nexport type GuardMatch = v.InferOutput<typeof GuardMatchSchema>\n\nconst GuardSchema = v.strictObject({\n name: v.optional(v.string()),\n description: v.optional(v.string()),\n match: GuardMatchSchema,\n /\n Lake GROQ predicate. Reads `document.before`/`document.after`, `mutation`,\n * `guard`, and `identity()`. Bare ids/fields only — no GDRs. Omitted or\n * empty means UNCONDITIONAL DENY.\n /\n predicate: v.optional(v.string()),\n /\n Projected workflow state the predicate reads as `guard.metadata.`. Values\n are `Source`s resolved at deploy and re-synced by the engine. Copied data,\n * never a cross-resource pointer.\n /\n metadata: v.optional(v.record(NonEmpty, SourceSchema)),\n})\nexport type Guard = v.InferOutput<typeof GuardSchema>\n\n// Stages\n\nconst StageKindSchema = picklist(['initial', 'intermediate', 'terminal', 'waiting'])\nexport type StageKind = v.InferOutput<typeof StageKindSchema>\n\nexport const StageSchema = v.strictObject({\n type: v.optional(v.literal('workflow.stage')),\n id: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n kind: v.optional(StageKindSchema),\n tasks: v.optional(v.array(TaskSchema)),\n transitions: v.optional(v.array(TransitionSchema)),\n completion: v.optional(FilterSchema),\n onEnter: v.optional(v.array(EffectSchema)),\n onExit: v.optional(v.array(EffectSchema)),\n /\n Lake mutation guards active while this stage holds. Each compiles to a\n * `temp.system.guard` doc deployed on stage entry and retracted on exit.\n * Plural because one stage's intent may span resources (one guard each).\n /\n guards: v.optional(v.array(GuardSchema)),\n contentRefs: v.optional(v.array(v.unknown())),\n /* Stage-scoped state slots. Resolved at stage entry and persisted on\n * the StageEntry. /\n state: v.optional(v.array(StateSlotSchema)),\n})\nexport type Stage = v.InferOutput<typeof StageSchema>\n\n// Workflow definition (the root)\n\n/\n Structural schema for a workflow definition. Cross-field invariants\n * (unique ids, transition/predicate references, terminal-stage rules)\n * are checked separately by `checkWorkflowInvariants` after this parse\n * succeeds — see `defineWorkflow`.\n /\nexport const WorkflowDefinitionSchema = v.strictObject({\n workflowId: NonEmpty,\n version: PositiveInt,\n title: NonEmpty,\n description: v.optional(v.string()),\n initialStageId: NonEmpty,\n /\n Workflow-level state slots. Persist for the instance lifetime.\n * Every stage's filters/ops can read them via\n * `[_id == $self][0].state[key == \"<key>\"][0].value`. Init-sourced\n slots are supplied at `startInstance` via `initialState`.\n /\n state: v.optional(v.array(StateSlotSchema)),\n stages: v.pipe(v.array(StageSchema), v.minLength(1, 'must declare at least one stage')),\n predicates: v.optional(v.array(PredicateSchema)),\n})\n\n/\n Workflow definition — inferred from the schema so authoring types\n * and runtime validation share one source of truth.\n /\nexport type WorkflowDefinition = v.InferOutput<typeof WorkflowDefinitionSchema>\n\n/\n The lake document type for a deployed workflow definition. Single source of\n * truth — every tag-scoped lookup query and the deploy write derive their\n * `_type` from here, mirroring {@link WORKFLOW_INSTANCE_TYPE}.\n */\nexport const WORKFLOW_DEFINITION_TYPE = 'workflow.definition'\n\n// Error formatting — turn validation issues into a multi-line,\n// path-prefixed message that points at the exact field the author got\n// wrong. Shared by structural parse errors (via {@link issuesFromValibot})\n// and cross-field invariant issues.\n\nexport interface ValidationIssue {\n path: ReadonlyArray<PropertyKey>\n message: string\n}\n\nexport function formatValidationError(label: string, issues: readonly ValidationIssue[]): string {\n const lines = issues.map((issue) => {\n const path = issue.path.length === 0 ? '(root)' : formatPath(issue.path)\n return ` - ${path}: ${issue.message}`\n })\n return `${label} failed validation (${issues.length} issue${\n issues.length === 1 ? '' : 's'\n }):\\n${lines.join('\\n')}`\n}\n\nexport function issuesFromValibot(issues: readonly v.BaseIssue<unknown>[]): ValidationIssue[] {\n return issues.map((issue) => ({\n path: issue.path ? issue.path.map((item) => item.key as PropertyKey) : [],\n message: issue.message,\n }))\n}\n\nfunction formatPath(path: ReadonlyArray<PropertyKey>): string {\n let out = ''\n for (const seg of path) {\n if (typeof seg === 'number') out += `[${seg}]`\n else out += out.length === 0 ? String(seg) : `.${String(seg)}`\n }\n return out\n}\n"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"schema.js","sources":["../../src/types/enums.ts","../../src/define/schema.ts"],"sourcesContent":["/*\n Leaf enums — the const arrays (and their derived union types) that both\n * the authoring schema and the engine address by name.\n \n This module imports nothing. It is the schema-free foundation that\n * `../define/schema.ts` reads its value constants from, which is what keeps\n * the type model and the valibot schema free of an import cycle: the value edge\n * `schema.ts → enums.ts` terminates here.\n /\n\n// Task status — used by instance state. The authored action `status:` sugar\n// (and the `status.set` op it desugars to) is constrained to the terminal\n// subset below.\nexport const TASK_STATUSES = ['pending', 'active', 'done', 'skipped', 'failed'] as const\nexport type TaskStatus = (typeof TASK_STATUSES)[number]\n\n// The statuses a task can be resolved INTO — what `status.set` accepts and\n// what stops blocking the `$allTasksDone` gate family.\nexport const TERMINAL_TASK_STATUSES = ['done', 'skipped', 'failed'] as const\nexport type TerminalTaskStatus = (typeof TERMINAL_TASK_STATUSES)[number]\n\nexport function isTerminalTaskStatus(status: TaskStatus): status is TerminalTaskStatus {\n return (TERMINAL_TASK_STATUSES as readonly TaskStatus[]).includes(status)\n}\n\n// The three state scopes a state entry can live in. Authoring (`ScopeKey`,\n// `stateRead` sources) and the engine both address state entries by scope.\nexport const STATE_SCOPES = ['workflow', 'stage', 'task'] as const\nexport type StateScope = (typeof STATE_SCOPES)[number]\n\n// Document-value permissions. Grants (`Grant` in ./authorization.ts) compose\n// most-permissive-wins.\nexport const DOCUMENT_VALUE_PERMISSIONS = ['create', 'read', 'update'] as const\nexport type DocumentValuePermission = (typeof DOCUMENT_VALUE_PERMISSIONS)[number]\n\n// Mutation-guard actions — the lake operations a guard can gate. See the\n// guard types in ./authorization.ts.\nexport const MUTATION_GUARD_ACTIONS = [\n 'create',\n 'update',\n 'delete',\n 'publish',\n 'unpublish',\n] as const\nexport type MutationGuardAction = (typeof MUTATION_GUARD_ACTIONS)[number]\n","/\n Valibot schemas for the workflow authoring surface — the things a workflow\n * author writes by hand and feeds to `defineWorkflow`. Types in this\n * file are the canonical authoring types: they are inferred from\n * the schemas, so the runtime schema and the compile-time type cannot\n * drift.\n \n Two layers live here, mirroring the design model (generic stored data,\n * sugar that compiles away):\n \n - Stored schemas (`WorkflowDefinitionSchema`, `OpSchema`, …) describe\n * the primitives the engine persists. No sugar variants, every state\n * reference carries an explicit resolved `scope`.\n * - Authoring schemas (`AuthoringWorkflowSchema`, …) accept the same\n * primitives plus define-time sugar: the `claim` state/action pair,\n * the `audit` op, the `roles` and `status` action fields, omitted\n * transition filters, omitted reference scopes. `desugar.ts` expands\n * authoring input into the stored shape.\n \n Strictness: every object schema is `v.strictObject` so unknown keys\n * produce a parse error. That catches typos like `verison: 1` at deploy\n * time — and it is also what enforces each sugar contract's reserved\n * fields (an `ops:` on a `claim` action is an unknown key, fail loud).\n /\n\nimport as v from 'valibot'\n\nimport {\n MUTATION_GUARD_ACTIONS,\n STATE_SCOPES,\n TASK_STATUSES,\n TERMINAL_TASK_STATUSES,\n} from '../types/enums.ts'\n\nconst NonEmpty = v.pipe(v.string(), v.minLength(1, 'must be a non-empty string'))\n\nconst PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1))\n\n/*\n Names that get spliced into GROQ — state entries (`$state.<name>` in the\n * claim no-steal filter and every condition) and predicate keys (`$<name>`).\n * A name like `review-owner` would parse as subtraction inside GROQ and\n * silently change the expression's meaning, so these are constrained to\n * GROQ-identifier-safe names. See {@link GROQ_IDENTIFIER}.\n /\nexport const GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]$/\n\nfunction groqIdentifier(referencedAs: string) {\n return v.pipe(\n v.string(),\n v.regex(\n GROQ_IDENTIFIER,\n `must be a GROQ-safe identifier (letters, digits, underscore; not starting with a digit) ` +\n `because it is referenced as ${referencedAs} in GROQ conditions`,\n ),\n )\n}\n\n/*\n Picklist with a zod-compatible \"Invalid option\" message that lists every\n * allowed value, so a typo'd discriminator or enum lands with a message an\n * author can act on (e.g. `Invalid option: expected one of \"done\"\|\"skipped\"`).\n /\nfunction picklist<const TOptions extends readonly [string, ...string[]]>(options: TOptions) {\n return v.picklist(\n options,\n `Invalid option: expected one of ${options.map((o) => `\"${o}\"`).join('\|')}`,\n )\n}\n\n// Source — the single \"where a value comes from\" union, shared by state-entry\n// origins and op payloads. Conditions and effect bindings are NOT Sources —\n// they are GROQ strings over the rendered scope ($state, $actor, $row, …).\n// Each value variant has a rendered $-twin (actor ↔ $actor, now ↔ $now) so\n// learning one side teaches the other.\n\ntype SourceInternal =\n \| {type: 'init'}\n \| {type: 'write'}\n \| {type: 'query'; query: string}\n \| {type: 'literal'; value: unknown}\n \| {type: 'param'; param: string}\n \| {type: 'actor'}\n \| {type: 'now'}\n \| {type: 'self'}\n \| {type: 'stage'}\n \| {\n type: 'stateRead'\n scope?: 'workflow' \| 'stage' \| undefined\n state: string\n path?: string \| undefined\n }\n \| {type: 'object'; fields: Record<string, SourceInternal>}\n\nconst SourceSchema: v.GenericSchema<SourceInternal> = v.lazy(() =>\n v.union([\n // State-entry origins: who fills the entry, and when.\n v.strictObject({type: v.literal('init')}),\n v.strictObject({type: v.literal('write')}),\n v.strictObject({\n type: v.literal('query'),\n query: NonEmpty,\n }),\n // Value sources: resolved to concrete JSON when an op or seed applies.\n v.strictObject({type: v.literal('literal'), value: v.unknown()}),\n v.strictObject({type: v.literal('param'), param: NonEmpty}),\n v.strictObject({type: v.literal('actor')}),\n v.strictObject({type: v.literal('now')}),\n v.strictObject({type: v.literal('self')}),\n v.strictObject({type: v.literal('stage')}),\n v.strictObject({\n type: v.literal('stateRead'),\n scope: v.optional(v.union([v.literal('workflow'), v.literal('stage')])),\n state: NonEmpty,\n path: v.optional(v.string()),\n }),\n v.strictObject({\n type: v.literal('object'),\n fields: v.record(NonEmpty, SourceSchema),\n }),\n ]),\n)\nexport type Source = SourceInternal\n\n// State references — `{ scope?, state }` addressing a state entry by name.\n// Authoring may omit `scope`; desugar resolves it lexically (task → stage →\n// workflow), so the STORED form always carries an explicit scope.\n\nconst StoredStateRefSchema = v.strictObject({\n scope: picklist(STATE_SCOPES),\n state: NonEmpty,\n})\nexport type StoredStateRef = v.InferOutput<typeof StoredStateRefSchema>\n\nconst AuthoringStateRefSchema = v.strictObject({\n scope: v.optional(picklist(STATE_SCOPES)),\n state: NonEmpty,\n})\nexport type AuthoringStateRef = v.InferOutput<typeof AuthoringStateRefSchema>\n\n// Op predicates — small typed predicate for state.updateWhere /\n// state.removeWhere. Runs in the pure in-memory op path, so it stays a\n// typed structure rather than GROQ. Discriminated by `type` like every union.\n\ntype OpPredicateInternal =\n \| {type: 'field'; field: string; equals: Source}\n \| {type: 'all'; of: OpPredicateInternal[]}\n \| {type: 'any'; of: OpPredicateInternal[]}\n\nconst OpPredicateSchema: v.GenericSchema<OpPredicateInternal> = v.lazy(() =>\n v.union([\n v.strictObject({\n type: v.literal('field'),\n field: NonEmpty,\n equals: SourceSchema,\n }),\n v.strictObject({type: v.literal('all'), of: v.array(OpPredicateSchema)}),\n v.strictObject({type: v.literal('any'), of: v.array(OpPredicateSchema)}),\n ]),\n)\nexport type OpPredicate = OpPredicateInternal\n\n// Ops — the six stored mutation primitives. `value` is the one payload key.\n// `status.set` may name a sibling task; desugar fills the firing task when\n// authoring omitted it, so the stored op always carries `task`.\n\nfunction opSchemas<T extends v.GenericSchema>(targetSchema: T) {\n return [\n v.strictObject({\n type: v.literal('state.set'),\n target: targetSchema,\n value: SourceSchema,\n }),\n v.strictObject({\n type: v.literal('state.unset'),\n target: targetSchema,\n }),\n v.strictObject({\n type: v.literal('state.append'),\n target: targetSchema,\n value: SourceSchema,\n }),\n v.strictObject({\n type: v.literal('state.updateWhere'),\n target: targetSchema,\n where: OpPredicateSchema,\n value: SourceSchema,\n }),\n v.strictObject({\n type: v.literal('state.removeWhere'),\n target: targetSchema,\n where: OpPredicateSchema,\n }),\n ] as const\n}\n\nconst StoredOpSchema = v.variant('type', [\n ...opSchemas(StoredStateRefSchema),\n v.strictObject({\n type: v.literal('status.set'),\n task: NonEmpty,\n status: picklist(TASK_STATUSES),\n }),\n])\nexport type Op = v.InferOutput<typeof StoredOpSchema>\n\n/\n The `state.` subset a transition may carry — `status.set` has no coherent\n task target while the stage's tasks tear down, so the engine rejects it\n * at parse time rather than dropping it silently.\n /\nconst StoredTransitionOpSchema = v.variant('type', [...opSchemas(StoredStateRefSchema)])\nexport type TransitionOp = v.InferOutput<typeof StoredTransitionOpSchema>\n\n// Authoring ops: scope optional on targets, `task` optional on status.set\n// (defaults to the firing task), plus the `audit` sugar type — a stamped\n// append whose expansion merges `actor`/`at` Source fields into its own value.\n\nconst AuditOpSchema = v.strictObject({\n type: v.literal('audit'),\n target: AuthoringStateRefSchema,\n value: SourceSchema,\n stampFields: v.optional(\n v.strictObject({\n actor: v.optional(NonEmpty),\n at: v.optional(NonEmpty),\n }),\n ),\n})\n\nexport const AuthoringOpSchema = v.variant('type', [\n ...opSchemas(AuthoringStateRefSchema),\n v.strictObject({\n type: v.literal('status.set'),\n task: v.optional(NonEmpty),\n status: picklist(TASK_STATUSES),\n }),\n AuditOpSchema,\n])\nexport type AuthoringOp = v.InferOutput<typeof AuthoringOpSchema>\n\n// State entries — the generic stored data. Kinds are bare: a discriminator is\n// unique within its union; namespaces live only on engine-owned lake document\n// `_type`s ({@link WORKFLOW_DEFINITION_TYPE}, the instance type).\n\nconst StateKindSchema = picklist([\n 'doc.ref',\n 'doc.refs',\n // Release reference. A workflow declares this entry to say \"I target a\n // Content Release\"; the runtime fills it at start time and auto-derives\n // the instance's read perspective from it.\n 'release.ref',\n 'query',\n 'value.string',\n 'value.url',\n 'value.number',\n 'value.boolean',\n 'value.dateTime',\n 'value.actor',\n 'checklist',\n 'notes',\n // The WHO-FOR entry: the inbox reverse-query reads it by kind, and the\n // rendered `$assigned` gate matches the caller against it.\n 'assignees',\n])\n\nconst StateEntryName = groqIdentifier('`$state.<name>`')\n\nconst StateEntrySchema = v.strictObject({\n type: StateKindSchema,\n name: StateEntryName,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n source: SourceSchema,\n})\nexport type StateEntry = v.InferOutput<typeof StateEntrySchema>\n\n/\n Authoring state accepts the raw entries plus the `claim` sugar type — the\n * state half of the mirrored claim pair. Expansion: `value.actor` with an\n * implied `write` source, strictly within this entry.\n /\nconst ClaimStateSchema = v.strictObject({\n type: v.literal('claim'),\n name: StateEntryName,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n})\n\nexport const AuthoringStateEntrySchema = v.union([StateEntrySchema, ClaimStateSchema])\nexport type AuthoringStateEntry = v.InferOutput<typeof AuthoringStateEntrySchema>\n\n// Conditions are raw GROQ strings over the rendered scope — built-in vars\n// ($state, $actor, $assigned, $can, $row, $effects, $subworkflows, $tasks,\n// $now, $allTasksDone, $anyTaskFailed) plus the author's nullary predicates.\n// There is no {ref, args} wrapper; parameterized reuse is a define-time\n// TypeScript function (see the `groq` tag in ./groq.ts).\n\nconst ConditionSchema = NonEmpty\nexport type Condition = string\n\n// Effects — the registry model. `name` is the effect's only identity; the\n// host app registers a handler against it (1:1) and the stored definition\n// never references code. Names are unique per definition (invariant) so\n// `$effects.<name>` is unambiguous.\n\nexport const EffectSchema = v.strictObject({\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n /* GROQ reads over the rendered scope, resolved to concrete JSON at queue time. /\n bindings: v.optional(v.record(v.string(), ConditionSchema)),\n /* Static config, passed through to the handler verbatim. /\n input: v.optional(v.record(v.string(), v.unknown())),\n})\nexport type Effect = v.InferOutput<typeof EffectSchema>\n\n// Actions\n\n/\n Caller-supplied params declared on an action. The engine validates\n * incoming `params` against this list before running ops or queuing\n * effects: missing required params → ActionParamsInvalidError, action\n * does not commit. Resolved values feed `Source.param` lookups.\n /\nconst ActionParamSchema = v.strictObject({\n type: picklist([\n 'string',\n 'number',\n 'boolean',\n 'url',\n 'dateTime',\n 'actor',\n 'doc.ref',\n 'doc.refs',\n 'json',\n ]),\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n required: v.optional(v.boolean()),\n})\nexport type ActionParam = v.InferOutput<typeof ActionParamSchema>\n\n/* Fields shared by the stored and authoring action shapes, parameterised\n * over the op schema (stored ops are fully resolved; authoring ops keep\n * their sugar). /\nfunction actionFields<Op extends v.GenericSchema>(op: Op) {\n return {\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n /\n The one gate mechanism: a condition over the rendered scope. Hard\n * enforcement lives outside the engine entirely (the lake ACL on the\n * documents, and guards) — every engine-evaluated gate is authoring/UX.\n /\n filter: v.optional(ConditionSchema),\n params: v.optional(v.array(ActionParamSchema)),\n ops: v.optional(v.array(op)),\n effects: v.optional(v.array(EffectSchema)),\n }\n}\n\nconst StoredActionSchema = v.strictObject(actionFields(StoredOpSchema))\nexport type Action = v.InferOutput<typeof StoredActionSchema>\n\nconst TerminalTaskStatus = picklist(TERMINAL_TASK_STATUSES)\n\n/\n Authoring action — the stored fields plus two field sugars with one\n * defined expansion each:\n \n - `roles` → a `count($actor.roles[@ in [...]]) > 0` membership condition\n * ANDed with the authored `filter`.\n * - `status` → a `status.set` op on the firing task, appended after\n * the authored ops (deliberately never implied: a forgotten explicit\n * `status` is a visible stall, an implied default silently completes\n * claim-like actions).\n /\nconst RawAuthoringActionSchema = v.strictObject({\n ...actionFields(AuthoringOpSchema),\n roles: v.optional(v.array(NonEmpty)),\n status: v.optional(TerminalTaskStatus),\n})\n\n/\n The action half of the mirrored claim pair. `state` references an\n * author-declared actor-valued entry (the pair's other half), resolved\n * lexically. Expansion, strictly within this action: a no-steal\n * `!defined($state.<state>)` filter ANDed with `roles`/`filter`, plus a\n * `state.set` ← actor op. `ops` and `status` are reserved (the expansion\n * owns them) — strictObject rejects them as unknown keys.\n /\nconst ClaimActionSchema = v.strictObject({\n type: v.literal('claim'),\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n state: v.union([NonEmpty, AuthoringStateRefSchema]),\n roles: v.optional(v.array(NonEmpty)),\n filter: v.optional(ConditionSchema),\n params: v.optional(v.array(ActionParamSchema)),\n effects: v.optional(v.array(EffectSchema)),\n})\n\nexport const AuthoringActionSchema = v.union([RawAuthoringActionSchema, ClaimActionSchema])\nexport type AuthoringAction = v.InferOutput<typeof AuthoringActionSchema>\n\n// Subworkflows — declare `subworkflows`, read `$subworkflows`. The spawning\n// task resolves like any task: `completeWhen` / `failWhen` over the rendered\n// `$subworkflows`; no `completeWhen` means all subworkflows done.\n\n/\n Logical reference to a deployed workflow definition, by its `name` (the\n * stable contract — tags can be renamed, workflows redeployed). The engine\n * resolves it at spawn time, ordering by `version desc` unless an explicit\n * `version` pins one.\n /\nconst DefinitionRefSchema = v.strictObject({\n name: NonEmpty,\n version: v.optional(v.union([PositiveInt, v.literal('latest')])),\n})\n\nconst SubworkflowsSchema = v.strictObject({\n /* GROQ producing one row per subworkflow; each row binds as `$row`. /\n forEach: NonEmpty,\n definition: DefinitionRefSchema,\n /* Initial state for each subworkflow — entry name → GROQ over `$row` + the parent scope. /\n with: v.optional(v.record(NonEmpty, ConditionSchema)),\n /\n Extra values evaluated in the parent's rendered scope at spawn time and\n * delivered into each subworkflow's `$effects` bag — the parent→child\n * handoff, read exactly like an effect output.\n /\n context: v.optional(v.record(NonEmpty, ConditionSchema)),\n})\nexport type Subworkflows = v.InferOutput<typeof SubworkflowsSchema>\n\n// Tasks — tasks own the ENTER moment: `ops` + `effects` run at activation,\n// `filter` makes activation conditional on the stage's entry state, and\n// `activation` switches the stage-enter flip (default `manual`: a task never\n// activates silently; \"auto\" is the explicit opt-in). A task with no actions\n// and no `completeWhen` is a machine step — it runs its activation payload\n// and resolves `done` immediately, leaving an audit row.\n\nfunction taskFields<\n TState extends v.GenericSchema,\n TAction extends v.GenericSchema,\n TOp extends v.GenericSchema,\n>(state: TState, action: TAction, op: TOp) {\n return {\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n activation: v.optional(picklist(['auto', 'manual'])),\n filter: v.optional(ConditionSchema),\n /\n Auto-completion condition — evaluated at activation and on every\n * cascade; truthy flips the task to `done` with a system actor. On a\n * spawning task it typically reads `$subworkflows`.\n /\n completeWhen: v.optional(ConditionSchema),\n /\n Auto-failure condition — symmetric to `completeWhen`, flips to\n * `failed`. When both are truthy on the same evaluation, `failWhen`\n * wins — failure is the more notable signal.\n /\n failWhen: v.optional(ConditionSchema),\n ops: v.optional(v.array(op)),\n effects: v.optional(v.array(EffectSchema)),\n actions: v.optional(v.array(action)),\n subworkflows: v.optional(SubworkflowsSchema),\n /* Task-scoped state entries. Resolved at task activation time. /\n state: v.optional(v.array(state)),\n }\n}\n\nconst StoredTaskSchema = v.strictObject(\n taskFields(StateEntrySchema, StoredActionSchema, StoredOpSchema),\n)\nexport type Task = v.InferOutput<typeof StoredTaskSchema>\n\nexport const AuthoringTaskSchema = v.strictObject(\n taskFields(AuthoringStateEntrySchema, AuthoringActionSchema, AuthoringOpSchema),\n)\nexport type AuthoringTask = v.InferOutput<typeof AuthoringTaskSchema>\n\n// Transitions — purely a condition over the rendered scope. Selection rule:\n// every transition is evaluated on every commit and cascade; the first truthy\n// `filter` in declaration order fires. No action coupling: a routing\n// difference is written into state by the action and read by the filter.\n\nfunction transitionFields<TOp extends v.GenericSchema, TFilter extends v.GenericSchema>(\n op: TOp,\n filter: TFilter,\n) {\n return {\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n to: NonEmpty,\n filter,\n /* The `state.` subset — state-write-on-move, the stage's EXIT/ARRIVAL payload. /\n ops: v.optional(v.array(op)),\n effects: v.optional(v.array(EffectSchema)),\n }\n}\n\nconst StoredTransitionSchema = v.strictObject(\n transitionFields(StoredTransitionOpSchema, ConditionSchema),\n)\nexport type Transition = v.InferOutput<typeof StoredTransitionSchema>\n\n/*\n Authoring transitions may omit `filter`; desugar fills the safe,\n * overwhelmingly-common gate `\"$allTasksDone\"`. \"Fire unconditionally\"\n * stays spellable as an explicit `filter: \"true\"`.\n /\nconst AuthoringTransitionOpSchema = v.variant('type', [\n ...opSchemas(AuthoringStateRefSchema),\n AuditOpSchema,\n])\nexport const AuthoringTransitionSchema = v.strictObject(\n transitionFields(AuthoringTransitionOpSchema, v.optional(ConditionSchema)),\n)\nexport type AuthoringTransition = v.InferOutput<typeof AuthoringTransitionSchema>\n\n// Guards — lake mutation guards. A FOREIGN CONTRACT mirrored 1:1: the\n// `temp.system.guard` doc's `match` / `predicate` / `metadata` fields are the\n// content lake's API, not engine surface, so authoring keeps the lake's\n// vocabulary verbatim. The engine adds exactly two things: `name` (authoring\n// identity — the lake `_id` derives from (instanceId, guard.name)) and\n// `$state`-read VALUES (`idRefs: [\"$state.subject\"]`, `metadata.outcome:\n// \"$state.outcome\"`), resolved at deploy into the bare values the contract\n// expects. Guards + the lake ACL are the only HARD gates in the system.\n\nconst GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS)\nexport type GuardAction = v.InferOutput<typeof GuardActionSchema>\n\nconst GuardMatchSchema = v.strictObject({\n /* Subject `_type`(s); empty matches any type. /\n types: v.optional(v.array(NonEmpty)),\n /* Target docs as `$state` reads (or `\"$self\"`), resolved at deploy to bare ids + the resource. /\n idRefs: v.optional(v.array(NonEmpty)),\n /* Glob id patterns (bare, resource-local). /\n idPatterns: v.optional(v.array(NonEmpty)),\n actions: v.pipe(\n v.array(GuardActionSchema),\n v.minLength(1, 'a guard must match at least one action'),\n ),\n})\nexport type GuardMatch = v.InferOutput<typeof GuardMatchSchema>\n\nexport const GuardSchema = v.strictObject({\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n match: GuardMatchSchema,\n /\n Lake GROQ predicate — a distinct eval context reading\n * `document.before`/`document.after`, `mutation`, `guard`, and\n * `identity()`. Bare ids/fields only. Omitted or empty means\n * UNCONDITIONAL DENY.\n /\n predicate: v.optional(v.string()),\n /\n Projected workflow state the predicate reads as `guard.metadata.` —\n the only bridge from the lake eval context (which cannot see `$state`)\n * to workflow state. Values are NOT GROQ: each is a deploy-time read in\n * the guard mini-language — `\"$self\"`, `\"$now\"`, or\n * `\"$state.<name>[.path]\"` — resolved into a bare value at deploy and\n * re-synced by the post-state-op guard refresh.\n /\n metadata: v.optional(v.record(NonEmpty, NonEmpty)),\n})\nexport type Guard = v.InferOutput<typeof GuardSchema>\n\n// Stages — pure containers: name / state / guards / tasks / transitions, no\n// behaviour of their own. Tasks own enter, transitions own exit and arrival.\n// `initial` is whatever `initialStage` names; a stage with no transitions IS\n// terminal (structural, nothing to declare or mis-declare).\n\nfunction stageFields<\n TState extends v.GenericSchema,\n TTask extends v.GenericSchema,\n TTransition extends v.GenericSchema,\n>(state: TState, task: TTask, transition: TTransition) {\n return {\n name: NonEmpty,\n title: v.optional(v.string()),\n description: v.optional(v.string()),\n tasks: v.optional(v.array(task)),\n transitions: v.optional(v.array(transition)),\n /\n Lake mutation guards active while this stage holds. Each compiles to a\n * `temp.system.guard` doc deployed on stage entry and retracted on exit.\n /\n guards: v.optional(v.array(GuardSchema)),\n /* Stage-scoped state entries. Resolved at stage entry. /\n state: v.optional(v.array(state)),\n }\n}\n\nconst StoredStageSchema = v.strictObject(\n stageFields(StateEntrySchema, StoredTaskSchema, StoredTransitionSchema),\n)\nexport type Stage = v.InferOutput<typeof StoredStageSchema>\n\nexport const AuthoringStageSchema = v.strictObject(\n stageFields(AuthoringStateEntrySchema, AuthoringTaskSchema, AuthoringTransitionSchema),\n)\nexport type AuthoringStage = v.InferOutput<typeof AuthoringStageSchema>\n\n// Workflow definition (the root)\n\nfunction workflowFields<TState extends v.GenericSchema, TStage extends v.GenericSchema>(\n state: TState,\n stage: TStage,\n) {\n return {\n name: NonEmpty,\n version: PositiveInt,\n title: NonEmpty,\n description: v.optional(v.string()),\n /* Reference field: named for the target, holds the stage's `name`. /\n initialStage: NonEmpty,\n /* Workflow-scope state entries. Persist for the instance lifetime. /\n state: v.optional(v.array(state)),\n stages: v.pipe(v.array(stage), v.minLength(1, 'must declare at least one stage')),\n /\n Nullary named conditions — each `name: groq` entry is pre-evaluated\n * and bound as the boolean `$name` var, composable with native GROQ.\n * Redefining a built-in var is a deploy error (never silently shadow).\n /\n predicates: v.optional(v.record(groqIdentifier('`$<name>`'), ConditionSchema)),\n }\n}\n\n/\n Structural schema for a STORED workflow definition — primitives only,\n * every reference scope resolved. Cross-field invariants (unique names,\n * transition targets, effect-name uniqueness, predicate shadowing) are\n * checked by `checkWorkflowInvariants` after desugar — see `defineWorkflow`.\n /\nconst WorkflowDefinitionSchema = v.strictObject(workflowFields(StateEntrySchema, StoredStageSchema))\nexport type WorkflowDefinition = v.InferOutput<typeof WorkflowDefinitionSchema>\n\n/* The authoring surface: stored primitives plus the define-time sugar. /\nexport const AuthoringWorkflowSchema = v.strictObject(\n workflowFields(AuthoringStateEntrySchema, AuthoringStageSchema),\n)\nexport type AuthoringWorkflow = v.InferOutput<typeof AuthoringWorkflowSchema>\n\n/\n The lake document type for a deployed workflow definition. Engine-owned\n * standalone documents carry the platform namespace; in-array discriminators\n * stay bare. Mirrors {@link WORKFLOW_INSTANCE_TYPE}.\n /\nexport const WORKFLOW_DEFINITION_TYPE = 'sanity.workflow.definition'\n\n// Error formatting — turn validation issues into a multi-line,\n// path-prefixed message that points at the exact field the author got\n// wrong. Shared by structural parse errors (via {@link issuesFromValibot})\n// and cross-field invariant issues.\n\nexport interface ValidationIssue {\n path: ReadonlyArray<PropertyKey>\n message: string\n}\n\n/* The buildable path form desugar and the invariants accumulate issues under. */\nexport type IssuePath = (string \| number)[]\n\nexport function formatValidationError(label: string, issues: readonly ValidationIssue[]): string {\n const lines = issues.map((issue) => {\n const path = issue.path.length === 0 ? '(root)' : formatPath(issue.path)\n return ` - ${path}: ${issue.message}`\n })\n return `${label} failed validation (${issues.length} issue${\n issues.length === 1 ? '' : 's'\n }):\\n${lines.join('\\n')}`\n}\n\nexport function issuesFromValibot(issues: readonly v.BaseIssue<unknown>[]): ValidationIssue[] {\n return issues.map((issue) => ({\n path: issue.path ? issue.path.map((item) => item.key as PropertyKey) : [],\n message: issue.message,\n }))\n}\n\nfunction formatPath(path: ReadonlyArray<PropertyKey>): string {\n let out = ''\n for (const seg of path) {\n if (typeof seg === 'number') out += `[${seg}]`\n else out += out.length === 0 ? String(seg) : `.${String(seg)}`\n }\n return out\n}\n"],"names":[],"mappings":"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"}