@sanity/workflow-engine 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,117 @@
 # @sanity/workflow-engine
 
+## 0.20.0
+
+### Minor Changes
+
+- ab5e454: Export project-user response validation for host adapters that consume Sanity project-user APIs.
+- e3122cc: New `instancesGuardQuery(instanceIds)` — the set-shaped guard filter (`sourceInstanceId in $instanceIds`, ordered by `_id`) reactive adapters subscribe as one shared live query per resource for every co-mounted session. `instanceGuardQuery(id)` delegates to it, so the per-instance and per-set reads share one filter definition; its compiled query string changes accordingly (same rows selected).
+- 7c4dd86: Reduce guard lifecycle request volume and chunk orphan cleanup transactions.
+
+### Patch Changes
+
+- bce09fc: Restore automatic effect request tags while preserving concrete handler client APIs, backed by native request-prefix support in the test client.
+- efb4cd9: Discriminator validation now reports an unknown field kind, field source, or op value expression at its exact `type` path instead of collapsing to "Invalid type: Expected Object but received Object". The schemas route on `type` rather than trying indistinguishable object arms in a plain union, so newer syntax used with an older engine identifies the unsupported value and the installed engine's valid options.
+- 46b0285: **BREAKING:** Replace manually declared document applicability with automatic
+  discovery from deployed first-class subject fields.
+
+  Update Studio configuration as follows:
+  - `mappings` is optional. Omit it when every applicable definition declares a
+    first-class subject. A mapping may customize an automatically discovered
+    `(docType, definition)` binding or explicitly register a definition modeled
+    with a plain `doc.ref` instead of a first-class subject.
+  - Multiple workflows may target one document type. Use one mapping row for each
+    distinct `(docType, definition)` pair. An exact duplicate pair is a
+    configuration error rather than a last-row-wins override.
+  - Remove the top-level `autoStart` map or function. Put `autoStart: true` on
+    each mapping row that should start automatically. Configure workspace-specific
+    behavior in that workspace's mapping rows. This also works for explicitly
+    registered definitions using the `doc.ref` field named `subject` convention.
+  - Replace `workflowDefaultDocumentNode({mappings})` with
+    `workflowDefaultDocumentNode()`.
+
+  Before:
+
+  ```ts
+  structureTool({defaultDocumentNode: workflowDefaultDocumentNode({mappings})})
+  workflowStudioPlugin({
+    tag: 'production',
+    mappings,
+    autoStart: {article: ['article-review', 'legal-review']},
+  })
+  ```
+
+  After:
+
+  ```ts
+  structureTool({defaultDocumentNode: workflowDefaultDocumentNode()})
+  workflowStudioPlugin({
+    tag: 'production',
+    mappings: [
+      {
+        docType: 'article',
+        definition: 'article-review',
+        label: 'Article review',
+        autoStart: true,
+      },
+      {
+        docType: 'article',
+        definition: 'legal-review',
+        label: 'Legal review',
+        autoStart: true,
+      },
+    ],
+  })
+  ```
+
+  Also remove all per-schema Editorial Workflows preview wiring:
+  - Remove `components: {preview: WorkflowStagePreview}`.
+  - Remove `_id` added only for Editorial Workflows from `preview.select` and
+    stop passing it through `preview.prepare`.
+  - Remove imports of `WorkflowStagePreview`; that component is no longer a
+    public package export.
+  - Remove imports of `mappingForDocType` and `workflowDocTypes`; effective
+    mappings are resolved inside the plugin and those host-side helpers are no
+    longer exported.
+  - Keep each schema's native inferred or custom preview unchanged. The plugin
+    now installs preview middleware itself, consumes the document identity Studio
+    already supplies, and delegates title, subtitle, media, and custom preview
+    composition through `renderDefault`.
+
+  Workflow stage pills appear on Studio surfaces that invoke preview middleware,
+  including reference and array-item previews. Custom preview components that
+  replace Studio's layout must render the `status` prop they receive. Studio's
+  Structure document-list rows bypass both plugin and schema preview middleware,
+  so they do not show workflow stage pills. Workflow status remains available in
+  the document form, footer badge, Workflows view, and Workflows tool.
+
+  Document-reference GDRs for dataset content now reject stored draft IDs
+  (`drafts.<id>`) and Content Release version IDs
+  (`versions.<release>.<id>`). Use the stable document ID in the GDR and select
+  the draft or release through workflow perspective instead. The validation error
+  includes the corresponding stable ID so CLI and API callers can correct the
+  input before an unresolvable workflow instance is created.
+
+  Previously persisted draft/version GDRs remain invalid workflow identities.
+  Read-side Studio displays now tolerate them by showing the raw URI instead of
+  crashing, and query-sourced occurrences are discarded through the existing
+  fail-soft field-resolution path. Correct existing data by starting a new
+  instance with the stable document ID; perspective selects the desired draft or
+  release content.
+
+- 8a76c67: Add incremental reactive-session document feeds, coalesce watched-document emissions, and reuse discovery derivations and Studio layout output. Deleted watched documents now leave the held snapshot instead of remaining as stale evaluation input. The component test runner also has aggregate-suite timeout headroom.
+- 7e8f459: Batch snapshot hydration to reduce watched-document read latency.
+- 98e488e: Stabilize Editorial Workflows discovery subscriptions and limit full reactive sessions to surfaces that need live evaluation.
+
+## 0.19.0
+
+### Minor Changes
+
+- 24b11dd: Effect handlers can report intermediate field state mid-dispatch. The handler context gains `ctx.commitOps({ops, idempotencyKey})` — field ops only, validated like completion ops, executed through the new `workflow.commitEffectOps` verb as a standard engine commit (gate, history, idempotency ledger, compare-and-swap persist, guard refresh, cascade) — and `ctx.setProgress(field, value)`, sugar that coalesces pending absolute sets per field. Calls enqueue synchronously into a bounded per-dispatch queue (depth 32, 200 commits per dispatch) that serializes commits in call order; overflow throws synchronously at the call site, and settlement drains the queue before completion so an un-awaited failed report still fails the effect. Pending-effect claims now carry a `claimToken` minted on every claim and takeover: a report from an expired, released, or superseded dispatch is rejected before writing (`StaleEffectClaimError`), and a successful report renews the claim's lease. Completion semantics are unchanged and remain claim-blind first-writer-wins. Each report emits the sampled `Editorial Workflows Effect State Reported` telemetry event (adoption signal, max one per minute). Persisted-model note: the claim token rides persisted model 3 additively (see `DATAMODEL.md`).
+- 2005ab7: Action evaluations carry a `firing` consequence (`FiringConsequence` `{exitsStage, transition?}`): what firing the action would do to the flow right now, computed by replaying the fire in memory through the same machinery a real commit runs — ops, the triggered fixpoint, then transition selection — against the projection's state. The answer is total for the current state and conditional on the commit landing; it is omitted where the replay can't be faithful (caller params, a spawn's dataset-driven fan-out in the hop, a terminal instance, a stage visit whose entries have diverged from the pinned definition) and on cascade-fired actions. Advisory, like every derived verdict. Wrong-shape `field.updateWhere` aborts (a merge resolving to a non-object; a resolved merge carrying reserved row keys) now throw the typed `FieldValueShapeError` on the commit path, joining the other wrong-shape write aborts.
+- 24b11dd: Add the `progress` field kind: an elevated `number` carrying application-defined 0–100 completion, so Studio and SDK surfaces can identify and elevate it without guessing which number field means "how far along". Every non-null value must be finite and within 0–100 inclusive (fractions allowed), enforced by one value schema at every write boundary — declaration seeds, start values, edits, ops, nested sub-fields, and effect outputs. Choice lists are rejected on the kind at authoring time. Mints persisted model 3 additively (see `DATAMODEL.md`).
+- 59b40fd: **BREAKING:** a deployment's `name` is now its identity in `defineWorkflowConfig`: enforced unique across the config and constrained to the same grammar as `tag` (lowercase letters, digits, dashes — free text like "My cool workflow" is rejected). Tags may now repeat across deployments; the enforced storage invariant is instead the `(workflowResource, tag)` pair — two deployments sharing both are rejected with each entry named, since they would write into the same partition and fight over definition versions.
+
 ## 0.18.0
 
 ### Minor Changes

package/DATAMODEL.md

@@ -445,6 +445,59 @@ Spread-based mutation copies preserve `validation` across every full persist;
 the derived floor prevents older writers from reaching constrained model-2
 instances.
 
+### Model 3 — the `progress` field kind + effect claim tokens (reader floor: 2)
+
+Two additive growths ship together as model 3 — model 2 was released (npm
+`@sanity/workflow-engine@0.18.0`) before either landed, so they mint the next
+version rather than amending a shipped one. Neither raises the reader floor;
+the writer maximum stays 2.
+
+**The `progress` field kind.** An elevated `number` (same stored numeric
+value) carrying application-defined 0–100 completion, so surfaces can
+identify and elevate it without guessing which number field means "how far
+along". Every non-null value is finite and within 0–100 inclusive (fractions
+allowed), enforced at every write boundary by the kind's one value schema.
+Model 2's `validation` tree composes with it as NARROWING only: each declared
+bound must itself sit within 0–100, gated at authoring. Both stamped trees
+grow the value:
+
+- **Definition tree** — `fields[].type` (and nested `FieldShape.type`)
+  admits `'progress'`.
+- **Instance tree** — resolved `fields[]` entries admit `_type: 'progress'`
+  (the same arm shape as `number`).
+
+Manifest feature: `progress-field-kind` (definition + instance, additive,
+detectable, floor 0).
+
+Would an old reader misread the kind (rule 5)? No — the same loud refusal as
+the `subject` kind: an older engine (model 2 and below) that loaded a
+progress-carrying instance fails the strict `fields[]` variant with
+`PersistedDocShapeError` before interpreting anything, and cannot deploy or
+evaluate a progress-declaring definition. No older code path can write a
+progress field while skipping its bound, so there is no silent bypass to
+fence — the kind leaves the floor at 0.
+
+**Effect claim tokens.** `pendingEffects[].claim` grows an optional
+`claimToken` — an opaque identifier minted fresh on every claim and
+takeover. It is the exact-claim identity a mid-dispatch state report
+(`commitEffectOps`) must present: `effectKey` cannot serve because a lease
+takeover keeps the same key. A successful report also renews the claim's
+`leaseExpiresAt` in the same commit.
+
+Manifest feature: `effect-claim-tokens` (instance, additive, detectable,
+floor 0).
+
+Tolerant read: an older engine's claim parse admits unknown keys, so the
+token rides through untouched and means nothing to it — older claim
+semantics (presence + lease) are unchanged. Round-trip survival: full
+persists derive from the complete loaded post-state, so an older writer
+carries the token along; the claim-REPLACING writes (takeover, sweep
+release, completion drain) discard it deliberately, which is the token's
+own lifecycle — a report presenting a discarded token is rejected before
+writing, failing closed. A claim without a token (older writer's takeover)
+simply cannot authorise mid-dispatch reports; dispatch and completion are
+unaffected.
+
 ## Pending governed changes
 
 - **`temp.system.guard` → `system.guard`** — the guard doc type's `temp.`

package/dist/_chunks-cjs/invariants.cjs

@@ -1,6 +1,6 @@
 "use strict";
 
-var v = require("valibot"), groqConditionDescribe = require("@sanity/groq-condition-describe"), groqJs = require("groq-js");
+var v = require("valibot"), groqConditionDescribe = require("@sanity/groq-condition-describe"), groqJs = require("groq-js"), idUtils = require("@sanity/id-utils");
 
 function _interopNamespaceCompat(e) {
     if (e && typeof e == "object" && "default" in e) return e;
@@ -129,7 +129,7 @@ function parentRef(instance) {
     return instance.ancestors.at(-1);
 }
 
-const DATA_MODEL_VERSION = 2, DATA_MODEL_MIN_READER = 2, READER_MODEL_ROLLOUT_URL = "https://github.com/sanity-io/workflows/blob/main/docs/reader-model-rollout.md";
+const DATA_MODEL_VERSION = 3, DATA_MODEL_MIN_READER = 2, READER_MODEL_ROLLOUT_URL = "https://github.com/sanity-io/workflows/blob/main/docs/reader-model-rollout.md";
 
 class ReaderModelAcknowledgementError extends WorkflowError {
     code="WORKFLOW_READER_MODEL_ACKNOWLEDGEMENT_MISMATCH";
@@ -188,6 +188,22 @@ const DATA_MODEL_CHANGES = Object.freeze([ Object.freeze({
     compatibility: "reader-floor",
     applicability: "detectable",
     summary: "String, text, and number values may carry persisted inclusive bounds."
+}), Object.freeze({
+    id: "progress-field-kind",
+    introducedInModel: 3,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "A progress field kind carries application-defined 0–100 completion."
+}), Object.freeze({
+    id: "effect-claim-tokens",
+    introducedInModel: 3,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Pending-effect claims carry an exact-claim token gating mid-dispatch state reports."
 }) ]);
 
 function recordOf(value) {
@@ -224,8 +240,8 @@ function hasChoiceList(document) {
     });
 }
 
-function hasSubjectField(document) {
-    return persistedFieldEntries(document).some(entry => entry.type === "subject" || entry._type === "subject");
+function hasFieldKind(document, kind) {
+    return persistedFieldEntries(document).some(entry => entry.type === kind || entry._type === kind);
 }
 
 function hasActionSemantics(document) {
@@ -240,12 +256,22 @@ function hasScalarValidation(document) {
     });
 }
 
+function hasClaimTokens(document) {
+    const root = recordOf(document);
+    return root === void 0 ? !1 : recordsAt(root, "pendingEffects").some(entry => {
+        const claim = recordOf(entry.claim);
+        return claim !== void 0 && typeof claim.claimToken == "string";
+    });
+}
+
 const featureDetectors = {
     "governed-model-stamps": () => !0,
-    "subject-field-kind": hasSubjectField,
+    "subject-field-kind": document => hasFieldKind(document, "subject"),
     "typed-scalar-choice-lists": hasChoiceList,
     "action-semantics": hasActionSemantics,
-    "inclusive-scalar-bounds": hasScalarValidation
+    "inclusive-scalar-bounds": hasScalarValidation,
+    "progress-field-kind": document => hasFieldKind(document, "progress"),
+    "effect-claim-tokens": hasClaimTokens
 };
 
 function requiredModelFeatures(documentType, document) {
@@ -332,6 +358,21 @@ function andConditions(parts) {
 
 const KNOWN_SCHEMES = /* @__PURE__ */ new Set([ "dataset", "canvas", "media-library", "dashboard" ]), KNOWN_SCHEMES_TEXT = [ ...KNOWN_SCHEMES ].join(", ");
 
+class VersionSpecificDatasetGdrError extends Error {
+    documentId;
+    stableDocumentId;
+    constructor(documentId, uri) {
+        const stableDocumentId = idUtils.getPublishedId(documentId);
+        super(`Invalid GDR "${uri}": dataset document ID "${documentId}" identifies a stored draft or release version. Use the stable document ID "${stableDocumentId}" and select drafts/releases through the workflow perspective.`), 
+        this.name = "VersionSpecificDatasetGdrError", this.documentId = documentId, this.stableDocumentId = stableDocumentId;
+    }
+}
+
+function assertStableDatasetDocumentId(documentId, uri) {
+    const sanityId = documentId;
+    if (!(!idUtils.isDraftId(sanityId) && !idUtils.isVersionId(sanityId))) throw new VersionSpecificDatasetGdrError(documentId, uri);
+}
+
 function parseGdr(uri) {
     const colon = uri.indexOf(":");
     if (colon < 0) throw new Error(`Invalid GDR "${uri}": must be a URI of form "<scheme>:<...id-parts>". Known schemes: ${KNOWN_SCHEMES_TEXT}.`);
@@ -341,11 +382,12 @@ function parseGdr(uri) {
     if (parts.some(part => part.length === 0)) throw new Error(`Invalid GDR "${uri}": id parts must be non-empty (no leading, trailing, or doubled ":").`);
     if (scheme === "dataset") {
         if (parts.length !== 3) throw new Error(`Invalid GDR "${uri}": dataset scheme requires <projectId>:<dataset>:<documentId> (3 parts after scheme); got ${parts.length}.`);
-        return {
+        const documentId = parts[2];
+        return assertStableDatasetDocumentId(documentId, uri), {
             scheme: "dataset",
             projectId: parts[0],
             dataset: parts[1],
-            documentId: parts[2]
+            documentId: documentId
         };
     }
     if (parts.length !== 2) throw new Error(`Invalid GDR "${uri}": ${scheme} scheme requires <resourceId>:<documentId> (2 parts after scheme); got ${parts.length}.`);
@@ -365,7 +407,11 @@ function tryParseGdr(uri) {
 }
 
 function gdrUri(parts) {
-    return parts.scheme === "dataset" ? `dataset:${parts.projectId}:${parts.dataset}:${parts.documentId}` : `${parts.scheme}:${parts.resourceId}:${parts.documentId}`;
+    if (parts.scheme === "dataset") {
+        const uri = `dataset:${parts.projectId}:${parts.dataset}:${parts.documentId}`;
+        return assertStableDatasetDocumentId(parts.documentId, uri), uri;
+    }
+    return `${parts.scheme}:${parts.resourceId}:${parts.documentId}`;
 }
 
 function extractDocumentId(gdrUriString) {
@@ -547,7 +593,13 @@ function asPredicate(validate) {
     };
 }
 
-const isValidTag = asPredicate(validateTag), isValidAliasName = asPredicate(validateResourceAliasName), isValidDatasetId = asPredicate(datasetResourceParts), WorkflowResourceSchema = v__namespace.variant("type", [ v__namespace.object({
+const isValidTag = asPredicate(validateTag), isValidAliasName = asPredicate(validateResourceAliasName), isValidDatasetId = asPredicate(datasetResourceParts);
+
+function lakeSegment(label) {
+    return v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty(), v__namespace.check(isValidTag, `invalid ${label} — ${LAKE_ID_SEGMENT_GLOSS}`));
+}
+
+const WorkflowResourceSchema = v__namespace.variant("type", [ v__namespace.object({
     type: v__namespace.literal("dataset"),
     id: v__namespace.pipe(NonEmptyString$1, v__namespace.check(isValidDatasetId, 'invalid dataset resource id — expected "<projectId>.<dataset>"'))
 }), v__namespace.object({
@@ -563,14 +615,46 @@ const isValidTag = asPredicate(validateTag), isValidAliasName = asPredicate(vali
     name: v__namespace.pipe(NonEmptyString$1, v__namespace.check(isValidAliasName, "invalid resource handle name — lowercase letters, digits and dashes only, no leading dash")),
     resource: WorkflowResourceSchema
 }), DefinitionSchema = v__namespace.custom(input => typeof input == "object" && input !== null && typeof input.name == "string", "expected a workflow definition (an object with a string `name`)"), DeploymentSchema = v__namespace.object({
-    name: NonEmptyString$1,
+    name: lakeSegment("name"),
     expectedMinReaderModel: v__namespace.optional(v__namespace.custom(() => !0), void 0),
-    tag: v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty(), v__namespace.check(isValidTag, "invalid tag — lowercase letters, digits and dashes only, no leading dash, no dots")),
+    tag: lakeSegment("tag"),
     workflowResource: WorkflowResourceSchema,
-    resourceAliases: v__namespace.optional(v__namespace.pipe(v__namespace.array(ResourceBindingSchema), v__namespace.check(bindings => new Set(bindings.map(binding => binding.name)).size === bindings.length, "duplicate resource handle name — each binding name must be unique within a deployment"))),
+    resourceAliases: v__namespace.optional(v__namespace.pipe(v__namespace.array(ResourceBindingSchema), v__namespace.check(bindings => duplicateHandleMessage(bindings) === void 0, issue => duplicateHandleMessage(issue.input) ?? "duplicate resource handle name"))),
     definitions: v__namespace.pipe(v__namespace.array(DefinitionSchema), v__namespace.minLength(1, "a deployment needs at least one definition"))
-}), TelemetryLoggerSchema = v__namespace.custom(input => typeof input == "object" && input !== null && typeof input.log == "function", "expected a telemetry logger (an object with a `log` function)"), WorkflowConfigSchema = v__namespace.object({
-    deployments: v__namespace.pipe(v__namespace.array(DeploymentSchema), v__namespace.minLength(1, "a config needs at least one deployment"), v__namespace.check(deployments => new Set(deployments.map(deployment => deployment.tag)).size === deployments.length, "duplicate deployment tag — each deployment must use a unique tag")),
+});
+
+function firstDuplicatePair(items, keyOf) {
+    const seen = /* @__PURE__ */ new Map;
+    for (const item of items) {
+        const key = keyOf(item), earlier = seen.get(key);
+        if (earlier !== void 0) return [ earlier, item ];
+        seen.set(key, item);
+    }
+}
+
+function duplicateHandleMessage(bindings) {
+    const pair = firstDuplicatePair(bindings, binding => binding.name);
+    if (pair !== void 0) return `duplicate resource handle name "${pair[1].name}" — each binding name must be unique within a deployment`;
+}
+
+function duplicateNameMessage(deployments) {
+    const pair = firstDuplicatePair(deployments, deployment => deployment.name);
+    if (pair !== void 0) return `duplicate deployment name "${pair[1].name}" — each deployment must use a unique name`;
+}
+
+function partitionKey(deployment) {
+    return `${resourceGdr(deployment.workflowResource)} ${deployment.tag}`;
+}
+
+function partitionCollisionMessage(deployments) {
+    const pair = firstDuplicatePair(deployments, partitionKey);
+    if (pair === void 0) return;
+    const [first, second] = pair;
+    return `deployments "${first.name}" and "${second.name}" share workflow resource + tag "${second.tag}" — both would write into the same partition; change one deployment’s tag or resource`;
+}
+
+const TelemetryLoggerSchema = v__namespace.custom(input => typeof input == "object" && input !== null && typeof input.log == "function", "expected a telemetry logger (an object with a `log` function)"), WorkflowConfigSchema = v__namespace.object({
+    deployments: v__namespace.pipe(v__namespace.array(DeploymentSchema), v__namespace.minLength(1, "a config needs at least one deployment"), v__namespace.check(deployments => duplicateNameMessage(deployments) === void 0, issue => duplicateNameMessage(issue.input) ?? "duplicate deployment name"), v__namespace.check(deployments => partitionCollisionMessage(deployments) === void 0, issue => partitionCollisionMessage(issue.input) ?? "duplicate deployment partition")),
     telemetry: v__namespace.optional(TelemetryLoggerSchema)
 });
 
@@ -1724,7 +1808,7 @@ const GdrUriSchema = v__namespace.custom(s => typeof s == "string" && isGdrUri(s
 }), tolerantObject()({
     type: v__namespace.literal("role"),
     role: NonEmptyString
-}) ]), NullableString = v__namespace.union([ v__namespace.null(), v__namespace.string() ]), NullableNumber = v__namespace.union([ v__namespace.null(), v__namespace.number() ]), NullableBoolean = v__namespace.union([ v__namespace.null(), v__namespace.boolean() ]), NullableDateTime = v__namespace.union([ v__namespace.null(), IsoTimestamp ]), NullableDate = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date")) ]), NullableUrl = NullableString, CHOICE_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "url", "date", "datetime", "dateTime" ]);
+}) ]), NullableString = v__namespace.union([ v__namespace.null(), v__namespace.string() ]), NullableNumber = v__namespace.union([ v__namespace.null(), v__namespace.number() ]), NullableBoolean = v__namespace.union([ v__namespace.null(), v__namespace.boolean() ]), NullableProgress = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.number(), v__namespace.finite("progress must be a finite number"), v__namespace.minValue(0, "progress must be at least 0"), v__namespace.maxValue(100, "progress must be at most 100")) ]), NullableDateTime = v__namespace.union([ v__namespace.null(), IsoTimestamp ]), NullableDate = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date")) ]), NullableUrl = NullableString, CHOICE_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "url", "date", "datetime", "dateTime" ]);
 
 function normalizedChoiceKind(kind) {
     return kind === "dateTime" ? "datetime" : kind;
@@ -1756,6 +1840,7 @@ const fieldValueSchemas = {
     string: NullableString,
     text: NullableString,
     number: NullableNumber,
+    progress: NullableProgress,
     boolean: NullableBoolean,
     date: NullableDate,
     datetime: NullableDateTime,
@@ -1780,13 +1865,13 @@ function shapeValueSchema(shape, leaf) {
 }
 
 function scalarMeasurement(entryType, value) {
-    if (entryType === "number" && typeof value == "number") return value;
+    if ((entryType === "number" || entryType === "progress") && typeof value == "number") return value;
     if ((entryType === "string" || entryType === "text") && typeof value == "string") return value.length;
 }
 
 function scalarBoundIssue(args) {
     const {entryType: entryType, measured: measured, bound: bound, limit: limit} = args;
-    return bound === void 0 || limit === "min" && measured >= bound || limit === "max" && measured <= bound ? void 0 : `${entryType === "number" ? "" : "length "}must be ${limit === "min" ? "greater than or equal to" : "less than or equal to"} ${bound}`;
+    return bound === void 0 || limit === "min" && measured >= bound || limit === "max" && measured <= bound ? void 0 : `${entryType === "number" || entryType === "progress" ? "" : "length "}must be ${limit === "min" ? "greater than or equal to" : "less than or equal to"} ${bound}`;
 }
 
 function scalarValidationIssues(args) {
@@ -1964,7 +2049,15 @@ function groqIdentifier(referencedAs) {
 }
 
 function picklist(options) {
-    return v__namespace.picklist(options, `Invalid option: expected one of ${options.map(o => `"${o}"`).join("|")}`);
+    return v__namespace.picklist(options, invalidOptionMessage(options));
+}
+
+function invalidOptionMessage(options) {
+    return `Invalid option: expected one of ${options.map(option => `"${option}"`).join("|")}`;
+}
+
+function exhaustiveOptions() {
+    return options => options;
 }
 
 function pinned() {
@@ -1979,12 +2072,12 @@ const LiteralSchema = v__namespace.strictObject({
     scope: v__namespace.optional(v__namespace.union([ v__namespace.literal("workflow"), v__namespace.literal("stage") ])),
     field: NonEmpty,
     path: v__namespace.optional(v__namespace.string())
-}), FieldSourceSchema = v__namespace.union([ v__namespace.strictObject({
+}), FieldSourceSchema = v__namespace.variant("type", [ v__namespace.strictObject({
     type: v__namespace.literal("input")
 }), v__namespace.strictObject({
     type: v__namespace.literal("query"),
     query: NonEmpty
-}), LiteralSchema, FieldReadSchema ]), ValueExprSchema = v__namespace.lazy(() => v__namespace.union([ LiteralSchema, FieldReadSchema, v__namespace.strictObject({
+}), LiteralSchema, FieldReadSchema ]), ValueExprSchema = v__namespace.lazy(() => v__namespace.variant("type", [ LiteralSchema, FieldReadSchema, v__namespace.strictObject({
     type: v__namespace.literal("param"),
     param: NonEmpty
 }), v__namespace.strictObject({
@@ -2079,7 +2172,7 @@ function groupMembershipNames(group) {
     return group === void 0 ? [] : typeof group == "string" ? [ group ] : [ ...group ];
 }
 
-const FIELD_VALUE_KINDS = [ "doc.ref", "doc.refs", "subject", "release.ref", "string", "text", "number", "boolean", "date", "datetime", "url", "actor", "assignee", "assignees", "object", "array" ], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), FieldEntryName = groqIdentifier("`$fields.<name>`"), FiniteNumber = v__namespace.pipe(v__namespace.number(), v__namespace.finite("must be finite")), ScalarValidationSchema = v__namespace.pipe(v__namespace.strictObject({
+const FIELD_VALUE_KINDS = [ "doc.ref", "doc.refs", "subject", "release.ref", "string", "text", "number", "progress", "boolean", "date", "datetime", "url", "actor", "assignee", "assignees", "object", "array" ], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), AUTHORING_FIELD_SUGAR_KINDS = exhaustiveOptions()([ "claim", "todoList", "notes" ]), AUTHORING_FIELD_KINDS = [ ...FIELD_VALUE_KINDS, ...AUTHORING_FIELD_SUGAR_KINDS ], AuthoringRawFieldKindSchema = v__namespace.picklist(FIELD_VALUE_KINDS, issue => `${invalidOptionMessage(AUTHORING_FIELD_KINDS)} but received ${JSON.stringify(issue.input)}`), FieldEntryName = groqIdentifier("`$fields.<name>`"), FiniteNumber = v__namespace.pipe(v__namespace.number(), v__namespace.finite("must be finite")), ScalarValidationSchema = v__namespace.pipe(v__namespace.strictObject({
     min: v__namespace.optional(FiniteNumber),
     max: v__namespace.optional(FiniteNumber)
 }), v__namespace.check(validation => validation.min !== void 0 || validation.max !== void 0, "declare at least one bound, or omit `validation`"), v__namespace.check(validation => validation.min === void 0 || validation.max === void 0 || validation.min <= validation.max, "`min` must be less than or equal to `max`")), ChoiceOptionsSchema = v__namespace.strictObject({
@@ -2144,9 +2237,9 @@ function fieldBase(editable, group) {
     };
 }
 
-function fieldEntryFields(editable, group) {
+function fieldEntryFields({editable: editable, group: group, kind: kind = FieldKindSchema}) {
     return {
-        type: FieldKindSchema,
+        type: kind,
         ...fieldBase(editable, group),
         options: v__namespace.optional(ChoiceOptionsSchema),
         validation: v__namespace.optional(ScalarValidationSchema),
@@ -2188,7 +2281,7 @@ function choiceOptionsCheck() {
     }) ?? []).join("; "));
 }
 
-const SCALAR_VALIDATION_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number" ]);
+const SCALAR_VALIDATION_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "progress" ]);
 
 function scalarValidationCheck() {
     return v__namespace.check(entry => scalarValidationDeclarationIssues(entry) === void 0, issue => (scalarValidationDeclarationIssues(issue.input) ?? []).join("; "));
@@ -2197,13 +2290,24 @@ function scalarValidationCheck() {
 function scalarValidationDeclarationIssues(entry) {
     const {type: type, validation: validation} = entry;
     if (validation === void 0) return;
-    if (!SCALAR_VALIDATION_KINDS.has(type)) return [ `\`validation\` is only valid on \`string\` / \`text\` / \`number\` values, not "${type}"` ];
+    if (!SCALAR_VALIDATION_KINDS.has(type)) return [ `\`validation\` is only valid on \`string\` / \`text\` / \`number\` / \`progress\` values, not "${type}"` ];
+    if (type === "progress") {
+        const issues2 = Object.entries(validation).flatMap(([bound, value]) => typeof value == "number" && value >= 0 && value <= 100 ? [] : [ `\`validation.${bound}\` must stay within the progress kind's 0–100 contract` ]);
+        return issues2.length === 0 ? void 0 : issues2;
+    }
     if (type === "number") return;
     const issues = Object.entries(validation).flatMap(([bound, value]) => Number.isInteger(value) && value >= 0 ? [] : [ `\`validation.${bound}\` must be a non-negative integer for ${type} length` ]);
     return issues.length === 0 ? void 0 : issues;
 }
 
-const FieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields(StoredEditableSchema, StoredGroupMembershipSchema)), refTypesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), RawAuthoringFieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields(AuthoringEditableSchema, AuthoringGroupMembershipSchema)), refTypesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), ClaimFieldSchema = pinned()(v__namespace.strictObject({
+const FieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
+    editable: StoredEditableSchema,
+    group: StoredGroupMembershipSchema
+})), refTypesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), RawAuthoringFieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
+    editable: AuthoringEditableSchema,
+    group: AuthoringGroupMembershipSchema,
+    kind: AuthoringRawFieldKindSchema
+})), refTypesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), ClaimFieldSchema = pinned()(v__namespace.strictObject({
     type: v__namespace.literal("claim"),
     name: FieldEntryName,
     title: v__namespace.optional(v__namespace.string()),
@@ -2218,7 +2322,10 @@ function listSugarFields(type) {
     };
 }
 
-const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(v__namespace.union([ RawAuthoringFieldEntrySchema, ClaimFieldSchema, TodoListFieldSchema, NotesFieldSchema ])), EffectSchema = v__namespace.strictObject({
+const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(v__namespace.lazy(input => {
+    const type = asShape(input).type;
+    return type === "claim" ? ClaimFieldSchema : type === "todoList" ? TodoListFieldSchema : type === "notes" ? NotesFieldSchema : RawAuthoringFieldEntrySchema;
+})), EffectSchema = v__namespace.strictObject({
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
@@ -3608,6 +3715,7 @@ const SCALAR = {
     string: () => SCALAR,
     text: () => SCALAR,
     number: () => SCALAR,
+    progress: () => SCALAR,
     boolean: () => SCALAR,
     date: () => SCALAR,
     datetime: () => SCALAR,
@@ -3811,6 +3919,8 @@ exports.SpawnContractsInvalidError = SpawnContractsInvalidError;
 
 exports.StoredFieldOpSchema = StoredFieldOpSchema;
 
+exports.VersionSpecificDatasetGdrError = VersionSpecificDatasetGdrError;
+
 exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
 
 exports.WORKFLOW_INSTANCE_TYPE = WORKFLOW_INSTANCE_TYPE;