deepline 0.3.409 → 0.3.410

package/dist/cli/{chunk-SEFMGO3Z.js → chunk-OQQOXSYA.js}

@@ -3,23 +3,23 @@
 var _chunk3KC45UVFjs = require('./chunk-3KC45UVF.js');
 
 
-var _chunkZ4VNJOF7js = require('./chunk-Z4VNJOF7.js');
 
 
 
 
 
 
-var _chunkS6R3OX7Bjs = require('./chunk-S6R3OX7B.js');
 
+var _chunkE4CABWXLjs = require('./chunk-E4CABWXL.js');
 
-var _chunk7P5AA3SNjs = require('./chunk-7P5AA3SN.js');
+
+
+var _chunkPPDBRJRWjs = require('./chunk-PPDBRJRW.js');
 
 
 var _chunkOG64RBACjs = require('./chunk-OG64RBAC.js');
 
 // src/plays/bundle-play-file.ts
-var _os = require('os');
 var _path = require('path');
 var _url = require('url');
 var _fs = require('fs');
@@ -29,7 +29,7 @@ var _promises = require('fs/promises');
 var _crypto = require('crypto');
 
 
-
+var _os = require('os');
 
 
 
@@ -47,17 +47,1822 @@ var _acorn = require('acorn');
 
 var _esbuild = require('esbuild');
 
+// ../plays/authoring-contract.ts
+var _typebox = require('@sinclair/typebox');
+var _value = require('@sinclair/typebox/value');
+var LEGACY_PLAY_AUTHORING_CONTRACT_EDITION = 1;
+var PLAY_AUTHORING_CONTRACT_EDITION = 11;
+var EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION = [
+  "Edition 11 requires an explicit choice.",
+  "`0` starts a fresh logical call, though a matching operation receipt may recover that same operation after resume;",
+  "`null` allows indefinite result reuse;",
+  "a positive integer is the maximum result age in seconds.",
+  "Omitted values retain legacy behavior in older editions."
+].join(" ");
+var SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11
+];
+var PLAY_AUTHORING_CONTRACT_CHANGELOG_DETAILS = [
+  {
+    changed: "Historical extraction semantics. Invalid or unresolved optional authoring fields may normalize to absence.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: "2026-11-03",
+    readerRemoval: "After every retained edition 1 artifact has a materialized admitted snapshot."
+  },
+  {
+    changed: "Pins admitted authoring snapshots and rejects ambiguous billing, secret, webhook, fetch, timeout, receipt-wait, and freshness contracts.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: "2026-08-03",
+    readerRemoval: "After every retained edition 2 artifact has an admitted input schema or has been republished."
+  },
+  {
+    changed: "Materializes the declared input schema in the admitted snapshot so launch never reparses current source.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: "2026-08-19",
+    readerRemoval: null
+  },
+  {
+    changed: "ctx.secrets.get(name) resolves an allowed secret to a plaintext string for ordinary Play code. Editions 1\u20133 retain opaque secret handles.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  },
+  {
+    changed: "ctx.fetch throws a typed, redacted CtxFetchHttpError for non-2xx responses. Editions 1\u20134 continue to return the response record for every HTTP status.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  },
+  {
+    changed: "Adds static cron input and rejects unknown definePlay and binding fields during new admission. Editions 1\u20135 retain their admitted binding semantics.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  },
+  {
+    changed: "Slack HITL calls that omit timeout wait one week. Editions 1\u20136 retain the historical 24-hour default.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  },
+  {
+    changed: "Lets an inline scalar child execute without a stored static pipeline. Dataset creation and suspension remain rejected by the authoritative runtime capability boundary; editions 1\u20137 retain static-contract preflight rejection.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  },
+  {
+    changed: "Projects native-batch rawV2 to the logical source response at the Play boundary. Editions 1\u20138 retain their admitted response nesting; completed tool receipts and provider identities are unchanged.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  },
+  {
+    changed: "List getters return ordinary arrays from the complete resident tool response. Lazy database datasets require an explicit dataset read; incomplete historical previews fail rather than masquerade as complete arrays. Editions 1\u20139 retain dataset-valued getters; stored tool receipts are unchanged.",
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  },
+  {
+    changed: 'Requires explicit freshness and semantic identity for supported durable calls, and gives edition 11 CSV datasets source-row occurrence identity so every input occurrence is processed even when key or rowIdentity: "key" is supplied. Edition 10 retains its list-getter behavior; editions 1\u201310 retain their admitted CSV identity and completed receipts. Non-CSV datasets keep explicit key deduplication.',
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  }
+];
+var PLAY_AUTHORING_CONTRACT_CHANGELOG = SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS.map((edition, index) => ({
+  edition,
+  ...PLAY_AUTHORING_CONTRACT_CHANGELOG_DETAILS[index]
+}));
+var PLAY_SQL_LISTENER_WHERE_OPERATORS = [
+  "eq",
+  "neq",
+  "in",
+  "notIn",
+  "isNull",
+  "isNotNull",
+  "ilike"
+];
+var PLAY_SQL_LISTENER_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+var PLAY_SQL_LISTENER_TOOL_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*\.[a-zA-Z][a-zA-Z0-9_-]*$/;
+var PLAY_SQL_LISTENER_WHERE_OPERATOR_SET = new Set(
+  PLAY_SQL_LISTENER_WHERE_OPERATORS
+);
+var PLAY_AUTHORING_BINDING_FIELDS = {
+  root: [
+    "displayName",
+    "billing",
+    "compatibility",
+    "cron",
+    "inline",
+    "runtime",
+    "secrets",
+    "sqlListeners",
+    "webhook"
+  ],
+  cron: ["schedule", "timezone", "input"],
+  webhook: ["auth", "hmac"],
+  sqlListener: [
+    "id",
+    "tool",
+    "stream",
+    "where",
+    "table",
+    "monitor",
+    "output",
+    "operations"
+  ]
+};
+var PLAY_AUTHORING_DEFINE_PLAY_OPTION_FIELDS = [
+  "id",
+  "name",
+  "description",
+  "input",
+  "run",
+  "bindings",
+  ...PLAY_AUTHORING_BINDING_FIELDS.root
+];
+var PLAY_AUTHORING_DOCUMENTATION = {
+  fetchBatching: {
+    warning: "A static ctx.fetch key inside a loop is a warning because every iteration must still have distinct method, URL, body, or safe headers. One durable receipt must never stand in for every request.",
+    guidance: "Keep the static fetch label. For a mutating batch, make the body distinct and use a replay-stable external Idempotency-Key such as `${ctx.run.id}:signals:${batchIndex}`."
+  },
+  runId: {
+    semantics: "ctx.run.id is stable while Deepline retries or resumes one durable run. A separately submitted run receives a new id.",
+    use: "Use it when deriving an external idempotency key for a sequence of batches."
+  },
+  staticCallKeys: {
+    constraint: "Durable call keys \u2014 the ctx.fetch key, the ctx.dataset key, the ctx.step id \u2014 must be static string literals. The key names a durable receipt, so check, publish, and replay have to agree on it before the body runs. A key computed at runtime cannot be resolved at check time and is rejected.",
+    consequence: "This is an architectural constraint, not a style rule. A play cannot loop over a computed key, so it cannot page a large table with a helper like page(pageNumber). Unrolling one literal key per page is not a design at any real page count.",
+    workaround: "Push the aggregation server-side and call it once: a SQL function, a view, or a provider endpoint that returns the whole result. Keep unrolled literal keys only for a handful of genuinely distinct calls. To fan out over rows, use ctx.dataset with a static key \u2014 the per-row receipt identity comes from the row, not from the key."
+  }
+};
+var PLAY_AUTHORING_STATIC_FETCH_KEY_HINT = `${PLAY_AUTHORING_DOCUMENTATION.staticCallKeys.workaround} Do not compute the key.`;
+var SecretEnvironmentNameSchema = _typebox.Type.String({
+  pattern: "^[A-Z][A-Z0-9_]{1,63}$",
+  description: "An uppercase environment variable name beginning with a letter."
+});
+var SqlListenerFilterScalarSchema = _typebox.Type.Union([
+  _typebox.Type.String(),
+  _typebox.Type.Number(),
+  _typebox.Type.Boolean(),
+  _typebox.Type.Null()
+]);
+var PLAY_AUTHORING_FIELD_REGISTRY = {
+  displayName: {
+    schema: _typebox.Type.String(),
+    fixtures: {
+      valid: "Find verified emails",
+      invalid: 42,
+      absent: void 0,
+      unresolved: { expression: "displayName" },
+      edition1: "Legacy play"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Optional human-readable Play name; empty uses the derived identifier.",
+    errorMessage: "displayName must be a static string."
+  },
+  description: {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich a company.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Legacy play."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Optional non-empty human-readable summary of the Play.",
+    errorMessage: "description must be a non-empty static string."
+  },
+  "compatibility.toolErrorSchemaVersion": {
+    schema: _typebox.Type.Union([_typebox.Type.Literal(0), _typebox.Type.Literal(1)]),
+    fixtures: {
+      valid: 1,
+      invalid: 2,
+      absent: void 0,
+      unresolved: { expression: "version" },
+      edition1: 0
+    },
+    referenceType: "0 | 1",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Artifact-pinned tool error behavior, either 0 or 1.",
+    errorMessage: "compatibility.toolErrorSchemaVersion must be the static literal 0 or 1."
+  },
+  "compatibility.authoringContract": {
+    schema: _typebox.Type.Literal("explicit-freshness"),
+    fixtures: {
+      valid: "explicit-freshness",
+      invalid: "legacy",
+      absent: void 0,
+      unresolved: { expression: "authoringContract" },
+      edition1: void 0
+    },
+    referenceType: "'explicit-freshness'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Opts new source into the current explicit-freshness authoring edition; an already-pinned edition-10 artifact retains its admitted behavior.",
+    errorMessage: 'compatibility.authoringContract must be the static literal "explicit-freshness".'
+  },
+  "compatibility.toolResponseReceiptRevision": {
+    schema: _typebox.Type.String({
+      minLength: 1,
+      maxLength: 64,
+      pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$"
+    }),
+    fixtures: {
+      valid: "raw-v2-receipt-v1",
+      invalid: "has spaces",
+      absent: void 0,
+      unresolved: { expression: "revision" },
+      edition1: void 0
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Explicit durable-receipt revision for a response transformation; bump only when serialized tool output changes.",
+    errorMessage: "compatibility.toolResponseReceiptRevision must be a non-empty static identifier using letters, numbers, dots, underscores, or hyphens."
+  },
+  inline: {
+    schema: _typebox.Type.Boolean(),
+    fixtures: {
+      valid: true,
+      invalid: "true",
+      absent: void 0,
+      unresolved: { expression: "inline" },
+      edition1: false
+    },
+    referenceType: "boolean",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Compiler hint for an inline named Play handler.",
+    errorMessage: "inline must be a static boolean."
+  },
+  "billing.maxCreditsPerRun": {
+    schema: _typebox.Type.Number({ exclusiveMinimum: 0 }),
+    fixtures: {
+      valid: 1,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "cap" },
+      edition1: 1
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_billing_limit_invalid",
+    description: "Maximum Deepline credits permitted for one Play Run.",
+    errorMessage: "billing.maxCreditsPerRun must be a static number greater than 0. Remove it for no run cap."
+  },
+  "bindings.webhook.hmac.secretEnv": {
+    schema: SecretEnvironmentNameSchema,
+    fixtures: {
+      valid: "WEBHOOK_SECRET",
+      invalid: "webhook_secret",
+      absent: void 0,
+      unresolved: { expression: "secretEnv" },
+      edition1: "WEBHOOK_SECRET"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_webhook_hmac_invalid",
+    description: "Environment variable containing the webhook HMAC secret.",
+    errorMessage: "bindings.webhook.hmac.secretEnv must be an uppercase environment variable name beginning with a letter."
+  },
+  "bindings.webhook.hmac.algorithm": {
+    schema: _typebox.Type.Literal("sha256"),
+    fixtures: {
+      valid: "sha256",
+      invalid: "sha1",
+      absent: void 0,
+      unresolved: { expression: "algorithm" },
+      edition1: "sha256"
+    },
+    referenceType: "'sha256'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_webhook_hmac_invalid",
+    description: "Webhook signature hash algorithm. Only sha256 is supported.",
+    errorMessage: 'bindings.webhook.hmac.algorithm must be the static literal "sha256".'
+  },
+  "bindings.webhook.hmac.header": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "x-signature",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "header" },
+      edition1: "x-signature"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_webhook_hmac_invalid",
+    description: "HTTP header containing the webhook signature.",
+    errorMessage: "bindings.webhook.hmac.header must be a non-empty static string."
+  },
+  "bindings.webhook.hmac.signaturePrefix": {
+    schema: _typebox.Type.String(),
+    fixtures: {
+      valid: "",
+      invalid: { expression: "signaturePrefix" },
+      absent: void 0,
+      unresolved: { expression: "signaturePrefix" },
+      edition1: void 0
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_webhook_hmac_invalid",
+    description: "Optional literal before the lowercase hexadecimal HMAC. Set to an empty string for providers that send a bare digest; defaults to sha256= when a signature header is configured.",
+    errorMessage: "bindings.webhook.hmac.signaturePrefix must be a static string literal."
+  },
+  "bindings.webhook.auth.type": {
+    schema: _typebox.Type.Literal("standard-webhooks"),
+    fixtures: {
+      valid: "standard-webhooks",
+      invalid: "svix",
+      absent: void 0,
+      unresolved: { expression: "type" },
+      edition1: void 0
+    },
+    referenceType: "'standard-webhooks'",
+    // auth itself is optional; once present, the AST adapter requires this
+    // field together with headerFamily and signingSecrets.
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Uses the Standard Webhooks v1 symmetric signing scheme.",
+    errorMessage: 'bindings.webhook.auth.type must be the static literal "standard-webhooks".'
+  },
+  "bindings.webhook.auth.headerFamily": {
+    schema: _typebox.Type.Union([_typebox.Type.Literal("standard"), _typebox.Type.Literal("svix")]),
+    fixtures: {
+      valid: "svix",
+      invalid: "webhook",
+      absent: void 0,
+      unresolved: { expression: "headerFamily" },
+      edition1: void 0
+    },
+    referenceType: "'standard' | 'svix'",
+    // auth itself is optional; once present, the AST adapter requires this
+    // field together with type and signingSecrets.
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Header namespace expected from the webhook provider.",
+    errorMessage: 'bindings.webhook.auth.headerFamily must be the static literal "standard" or "svix".'
+  },
+  "bindings.webhook.auth.signingSecrets[]": {
+    schema: SecretEnvironmentNameSchema,
+    fixtures: {
+      valid: "VECTOR_WEBHOOK_SECRET",
+      invalid: "vector_webhook_secret",
+      absent: void 0,
+      unresolved: { expression: "secret" },
+      edition1: void 0
+    },
+    referenceType: "string",
+    // auth itself is optional; once present, the AST adapter requires this
+    // field together with type and headerFamily.
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Deepline Secret name used to verify Standard Webhooks.",
+    errorMessage: "bindings.webhook.auth.signingSecrets entries must be uppercase Deepline Secret names beginning with a letter."
+  },
+  "bindings.webhook.auth.toleranceSeconds": {
+    schema: _typebox.Type.Integer({ minimum: 1, maximum: 3600 }),
+    fixtures: {
+      valid: 300,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "toleranceSeconds" },
+      edition1: void 0
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Accepted delivery timestamp skew in seconds, from 1 through 3600.",
+    errorMessage: "bindings.webhook.auth.toleranceSeconds must be a static whole number from 1 through 3600."
+  },
+  "bindings.cron.schedule": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "0 9 * * *",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "schedule" },
+      edition1: "0 9 * * *"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Five-field cron expression.",
+    errorMessage: "bindings.cron.schedule must be a non-empty static string."
+  },
+  "bindings.cron.timezone": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "UTC",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "timezone" },
+      edition1: "UTC"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_cron_timezone_invalid",
+    description: "IANA timezone. Omitted means UTC.",
+    errorMessage: "bindings.cron.timezone must be a valid non-empty IANA timezone string."
+  },
+  "bindings.cron.input": {
+    schema: _typebox.Type.Object({}, { additionalProperties: true }),
+    fixtures: {
+      valid: { apply: true },
+      invalid: ["apply"],
+      absent: void 0,
+      unresolved: ["cronInput"],
+      edition1: void 0
+    },
+    referenceType: "Record<string, unknown>",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Static JSON object passed to every run created by this cron binding.",
+    errorMessage: "bindings.cron.input must be a static JSON object (no variables, spreads, or functions)."
+  },
+  "bindings.sqlListeners": {
+    schema: _typebox.Type.Array(_typebox.Type.Object({}, { additionalProperties: true })),
+    fixtures: {
+      valid: [],
+      invalid: "listeners",
+      absent: void 0,
+      unresolved: { expression: "listeners" },
+      edition1: []
+    },
+    referenceType: "SqlListener[]",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Static provider-monitor listener declarations.",
+    errorMessage: "bindings.sqlListeners must be a static array of objects."
+  },
+  "bindings.sqlListeners[].id": {
+    schema: _typebox.Type.String({ pattern: PLAY_SQL_LISTENER_ID_PATTERN.source }),
+    fixtures: {
+      valid: "job-openings",
+      invalid: "1-job-openings",
+      absent: void 0,
+      unresolved: { expression: "listenerId" },
+      edition1: "job-openings"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Unique static listener identifier within one Play.",
+    errorMessage: "bindings.sqlListeners[].id must begin with a letter and contain only letters, numbers, underscores, or hyphens."
+  },
+  "bindings.sqlListeners[].tool": {
+    schema: _typebox.Type.String({ pattern: PLAY_SQL_LISTENER_TOOL_PATTERN.source }),
+    fixtures: {
+      valid: "deepline_native.company_radar",
+      invalid: "company_radar",
+      absent: void 0,
+      unresolved: { expression: "toolId" },
+      edition1: "deepline_native.company_radar"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Modeled provider monitor tool id in provider.tool form.",
+    errorMessage: "bindings.sqlListeners[].tool must use static provider.tool syntax."
+  },
+  "bindings.sqlListeners[].stream": {
+    schema: _typebox.Type.String({ pattern: PLAY_SQL_LISTENER_ID_PATTERN.source }),
+    fixtures: {
+      valid: "company_job_openings",
+      invalid: "1-company-job-openings",
+      absent: void 0,
+      unresolved: { expression: "stream" },
+      edition1: "company_job_openings"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Static output stream key exposed by the monitor tool.",
+    errorMessage: "bindings.sqlListeners[].stream must be a static stream identifier."
+  },
+  "bindings.sqlListeners[].operations[]": {
+    schema: _typebox.Type.Union([
+      _typebox.Type.Literal("INSERT"),
+      _typebox.Type.Literal("UPDATE"),
+      _typebox.Type.Literal("DELETE")
+    ]),
+    fixtures: {
+      valid: "INSERT",
+      invalid: "UPSERT",
+      absent: void 0,
+      unresolved: { expression: "operation" },
+      edition1: "UPDATE"
+    },
+    referenceType: "'INSERT' | 'UPDATE' | 'DELETE'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Database operation that wakes the listener.",
+    errorMessage: "bindings.sqlListeners[].operations entries must be INSERT, UPDATE, or DELETE."
+  },
+  "bindings.sqlListeners[].where.before": {
+    schema: _typebox.Type.Record(_typebox.Type.String(), _typebox.Type.Unknown()),
+    fixtures: {
+      valid: { status: { eq: "open" } },
+      invalid: "status=open",
+      absent: void 0,
+      unresolved: "beforeFilter",
+      edition1: { status: { eq: "open" } }
+    },
+    referenceType: "Record<string, SqlListenerFilterOperator>",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Column filters evaluated against the row before mutation.",
+    errorMessage: "bindings.sqlListeners[].where.before must be a static object keyed by column."
+  },
+  "bindings.sqlListeners[].where.after": {
+    schema: _typebox.Type.Record(_typebox.Type.String(), _typebox.Type.Unknown()),
+    fixtures: {
+      valid: { status: { eq: "open" } },
+      invalid: "status=open",
+      absent: void 0,
+      unresolved: "afterFilter",
+      edition1: { status: { eq: "open" } }
+    },
+    referenceType: "Record<string, SqlListenerFilterOperator>",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Column filters evaluated against the row after mutation.",
+    errorMessage: "bindings.sqlListeners[].where.after must be a static object keyed by column."
+  },
+  "bindings.sqlListeners[].where.*.*.eq": {
+    schema: SqlListenerFilterScalarSchema,
+    fixtures: {
+      valid: "open",
+      invalid: { nested: true },
+      absent: void 0,
+      unresolved: { expression: "equalsValue" },
+      edition1: "open"
+    },
+    referenceType: "SqlListenerFilterScalar",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Scalar equality condition.",
+    errorMessage: "SQL listener eq must compare a scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.neq": {
+    schema: SqlListenerFilterScalarSchema,
+    fixtures: {
+      valid: "closed",
+      invalid: { nested: true },
+      absent: void 0,
+      unresolved: { expression: "notEqualsValue" },
+      edition1: "closed"
+    },
+    referenceType: "SqlListenerFilterScalar",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Scalar inequality condition.",
+    errorMessage: "SQL listener neq must compare a scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.in": {
+    schema: _typebox.Type.Array(SqlListenerFilterScalarSchema, { minItems: 1 }),
+    fixtures: {
+      valid: ["open", "pending"],
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "acceptedValues" },
+      edition1: ["open"]
+    },
+    referenceType: "readonly SqlListenerFilterScalar[]",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Non-empty scalar membership condition.",
+    errorMessage: "SQL listener in must contain at least one scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.notIn": {
+    schema: _typebox.Type.Array(SqlListenerFilterScalarSchema, { minItems: 1 }),
+    fixtures: {
+      valid: ["closed"],
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "rejectedValues" },
+      edition1: ["closed"]
+    },
+    referenceType: "readonly SqlListenerFilterScalar[]",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Non-empty scalar exclusion condition.",
+    errorMessage: "SQL listener notIn must contain at least one scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.isNull": {
+    schema: _typebox.Type.Literal(true),
+    fixtures: {
+      valid: true,
+      invalid: false,
+      absent: void 0,
+      unresolved: { expression: "isNull" },
+      edition1: true
+    },
+    referenceType: "true",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Matches null values when set to true.",
+    errorMessage: "SQL listener isNull must be the static literal true."
+  },
+  "bindings.sqlListeners[].where.*.*.isNotNull": {
+    schema: _typebox.Type.Literal(true),
+    fixtures: {
+      valid: true,
+      invalid: false,
+      absent: void 0,
+      unresolved: { expression: "isNotNull" },
+      edition1: true
+    },
+    referenceType: "true",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Matches non-null values when set to true.",
+    errorMessage: "SQL listener isNotNull must be the static literal true."
+  },
+  "bindings.sqlListeners[].where.*.*.ilike": {
+    schema: _typebox.Type.String(),
+    fixtures: {
+      valid: "%software%",
+      invalid: 1,
+      absent: void 0,
+      unresolved: { expression: "pattern" },
+      edition1: "%software%"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Case-insensitive SQL pattern condition.",
+    errorMessage: "SQL listener ilike must be a string pattern."
+  },
+  "bindings.secrets[]": {
+    schema: SecretEnvironmentNameSchema,
+    fixtures: {
+      valid: "API_TOKEN",
+      invalid: "api_token",
+      absent: void 0,
+      unresolved: { expression: "secret" },
+      edition1: "API_TOKEN"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_secret_invalid",
+    description: "Environment variable made available to the Play.",
+    errorMessage: "bindings.secrets entries must be uppercase environment variable names beginning with a letter."
+  },
+  "ctx.tools.execute.staleAfterSeconds": {
+    schema: _typebox.Type.Union([_typebox.Type.Null(), _typebox.Type.Integer({ minimum: 0 })]),
+    fixtures: {
+      valid: 0,
+      invalid: -1,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: null
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
+    errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
+  },
+  "ctx.tools.execute.id": {
+    schema: _typebox.Type.String({ pattern: "\\S" }),
+    fixtures: {
+      valid: "company-enrichment",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "receiptId" },
+      edition1: "company-enrichment"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Stable durable receipt identity within one execution scope.",
+    errorMessage: "ctx.tools.execute id must be a non-empty string."
+  },
+  "ctx.tools.execute.tool": {
+    schema: _typebox.Type.String({ pattern: "\\S" }),
+    fixtures: {
+      valid: "openmart_enrich_company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "toolId" },
+      edition1: "openmart_enrich_company"
+    },
+    referenceType: "K",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Integration tool id resolved against the generated ToolMap.",
+    errorMessage: "ctx.tools.execute tool must be a non-empty tool id."
+  },
+  "ctx.tools.execute.input": {
+    schema: _typebox.Type.Record(_typebox.Type.String(), _typebox.Type.Unknown()),
+    fixtures: {
+      valid: { domain: "example.com" },
+      invalid: "example.com",
+      absent: void 0,
+      unresolved: "toolInput",
+      edition1: {}
+    },
+    referenceType: "K extends keyof ToolMap ? ToolMap[K]['input'] : Record<string, unknown>",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Tool-specific input object.",
+    errorMessage: "ctx.tools.execute input must be an object."
+  },
+  "ctx.tools.execute.description": {
+    schema: _typebox.Type.String(),
+    fixtures: {
+      valid: "Enrich the company.",
+      invalid: 1,
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Enrich the company."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Human-readable purpose of the durable tool call.",
+    errorMessage: "ctx.tools.execute description must be a string."
+  },
+  "ctx.tools.execute.force": {
+    schema: _typebox.Type.Boolean(),
+    fixtures: {
+      valid: true,
+      invalid: "true",
+      absent: void 0,
+      unresolved: { expression: "force" },
+      edition1: false
+    },
+    referenceType: "boolean",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Explicitly bypasses a completed durable tool receipt.",
+    errorMessage: "ctx.tools.execute force must be a boolean."
+  },
+  "ctx.tools.execute.timeoutMs": {
+    schema: _typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 1,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "timeout" },
+      edition1: 1
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Positive whole-number runtime transport timeout in milliseconds.",
+    errorMessage: "timeoutMs must be a positive whole number of milliseconds."
+  },
+  "ctx.tools.execute.receiptWaitMs": {
+    schema: _typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 1,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "receiptWait" },
+      edition1: 1
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Positive whole-number durable receipt wait budget in milliseconds.",
+    errorMessage: "receiptWaitMs must be a positive whole number of milliseconds."
+  },
+  "ctx.csv.options.description": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Load account rows.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Load rows."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Non-empty description for a staged CSV load.",
+    errorMessage: "ctx.csv options.description must be non-empty."
+  },
+  "ctx.csv.options.columns": {
+    schema: _typebox.Type.Record(
+      _typebox.Type.String(),
+      _typebox.Type.Union([
+        _typebox.Type.String({ minLength: 1 }),
+        _typebox.Type.Array(_typebox.Type.String({ minLength: 1 }), { minItems: 1 })
+      ])
+    ),
+    fixtures: {
+      valid: { domain: ["domain", "Company Domain"] },
+      invalid: { domain: [] },
+      absent: void 0,
+      unresolved: { expression: { dynamic: true } },
+      edition1: { domain: "domain" }
+    },
+    referenceType: "CsvRenameMap",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Canonical field-to-header aliases for a staged CSV.",
+    errorMessage: "ctx.csv options.columns values must be a non-empty header or alias list."
+  },
+  "ctx.csv.options.rename": {
+    schema: _typebox.Type.Record(
+      _typebox.Type.String(),
+      _typebox.Type.Union([
+        _typebox.Type.String({ minLength: 1 }),
+        _typebox.Type.Array(_typebox.Type.String({ minLength: 1 }), { minItems: 1 })
+      ])
+    ),
+    fixtures: {
+      valid: { domain: "Company Domain" },
+      invalid: { domain: "" },
+      absent: void 0,
+      unresolved: { expression: { dynamic: true } },
+      edition1: { domain: "domain" }
+    },
+    referenceType: "CsvRenameMap",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Legacy header rename aliases for a staged CSV.",
+    errorMessage: "ctx.csv options.rename values must be a non-empty header or alias list."
+  },
+  "ctx.csv.options.required": {
+    schema: _typebox.Type.Array(_typebox.Type.String({ minLength: 1 })),
+    fixtures: {
+      valid: ["domain"],
+      invalid: [""],
+      absent: void 0,
+      unresolved: { expression: "requiredColumns" },
+      edition1: []
+    },
+    referenceType: "readonly string[]",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Canonical columns required after CSV normalization.",
+    errorMessage: "ctx.csv options.required entries must be non-empty column names."
+  },
+  "ctx.dataset.key": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "accounts",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "datasetKey" },
+      edition1: "rows"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Stable durable identity for one dataset.",
+    errorMessage: "ctx.dataset key must be a non-empty static string."
+  },
+  "ctx.dataset.run.description": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich account rows.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Process rows."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Non-empty description for one dataset execution.",
+    errorMessage: "ctx.dataset run description must be non-empty."
+  },
+  "ctx.dataset.run.key": {
+    schema: _typebox.Type.Union([
+      _typebox.Type.String({ minLength: 1 }),
+      _typebox.Type.Array(_typebox.Type.String({ minLength: 1 }), { minItems: 1 }),
+      _typebox.Type.Function(
+        [_typebox.Type.Record(_typebox.Type.String(), _typebox.Type.Unknown()), _typebox.Type.Integer()],
+        _typebox.Type.Union([
+          _typebox.Type.String(),
+          _typebox.Type.Number(),
+          _typebox.Type.Readonly(_typebox.Type.Array(_typebox.Type.Unknown()))
+        ])
+      )
+    ]),
+    fixtures: {
+      valid: (row) => String(row.domain),
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "rowKey" },
+      edition1: ["domain"]
+    },
+    referenceType: "DatasetRowKey<InputRow>",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Stable field or fields used for durable row identity.",
+    errorMessage: "ctx.dataset run key must be a non-empty field, field list, or key function."
+  },
+  "ctx.dataset.run.rowIdentity": {
+    schema: _typebox.Type.Union([_typebox.Type.Literal("source_row"), _typebox.Type.Literal("key")]),
+    fixtures: {
+      valid: "source_row",
+      invalid: "dedupe",
+      absent: void 0,
+      unresolved: { expression: "rowIdentity" },
+      edition1: "key"
+    },
+    referenceType: "'source_row' | 'key'",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: 'Edition 11 requires explicit freshness and semantic identity for supported durable calls. CSV inputs always use source-row occurrence identity, even with rowIdentity: "key"; key-based dedup remains available for non-CSV inputs and editions 1\u201310.',
+    errorMessage: 'ctx.dataset run rowIdentity must be "source_row" or "key".'
+  },
+  "ctx.dataset.run.onRowError": {
+    schema: _typebox.Type.Union([_typebox.Type.Literal("isolate"), _typebox.Type.Literal("fail")]),
+    fixtures: {
+      valid: "isolate",
+      invalid: "continue",
+      absent: void 0,
+      unresolved: { expression: "rowErrorPolicy" },
+      edition1: "fail"
+    },
+    referenceType: "'isolate' | 'fail'",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Whether row failures isolate or fail the whole dataset.",
+    errorMessage: 'ctx.dataset run onRowError must be "isolate" or "fail".'
+  },
+  "ctx.dataset.run.mode": {
+    schema: _typebox.Type.Union([_typebox.Type.Literal("upsert"), _typebox.Type.Literal("net_new")]),
+    fixtures: {
+      valid: "upsert",
+      invalid: "append",
+      absent: void 0,
+      unresolved: { expression: "datasetMode" },
+      edition1: "upsert"
+    },
+    referenceType: "'upsert' | 'net_new'",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Whether the dataset returns all rows or only newly admitted rows.",
+    errorMessage: 'ctx.dataset run mode must be "upsert" or "net_new".'
+  },
+  "ctx.dataset.run.undrawnColumns": {
+    schema: _typebox.Type.Array(_typebox.Type.String({ minLength: 1 }), { minItems: 1 }),
+    fixtures: {
+      valid: ["miss_reason"],
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "undrawnColumns" },
+      edition1: ["miss_reason"]
+    },
+    referenceType: "readonly string[]",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Computed columns deliberately left out of the authored @mermaid diagram.",
+    errorMessage: "ctx.dataset run undrawnColumns must be a non-empty array of static column-name strings."
+  },
+  "ctx.step.id": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "load-settings",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "stepId" },
+      edition1: "step"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Stable durable identity for one scalar checkpoint.",
+    errorMessage: "ctx.step id must be a non-empty static string."
+  },
+  "ctx.step.semanticKey": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "account:stripe.com",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "semanticKey" },
+      edition1: "account"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Optional semantic receipt identity for a scalar checkpoint.",
+    errorMessage: "ctx.step semanticKey must be a non-empty string."
+  },
+  "ctx.step.staleAfterSeconds": {
+    schema: _typebox.Type.Union([_typebox.Type.Null(), _typebox.Type.Integer({ minimum: 0 })]),
+    fixtures: {
+      valid: 0,
+      invalid: -1,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: null
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
+    errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
+  },
+  "ctx.fetch.key": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "notify-crm",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "fetchKey" },
+      edition1: "fetch"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Stable durable identity for one external HTTP request.",
+    errorMessage: "ctx.fetch key must be a non-empty static string.",
+    unresolvedHint: PLAY_AUTHORING_STATIC_FETCH_KEY_HINT
+  },
+  "ctx.fetch.staleAfterSeconds": {
+    schema: _typebox.Type.Union([_typebox.Type.Null(), _typebox.Type.Integer({ minimum: 0 })]),
+    fixtures: {
+      valid: null,
+      invalid: 1.5,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: 0
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
+    errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
+  },
+  "ctx.runPlay.key": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "enrich-company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "callKey" },
+      edition1: "child"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Stable identity for one inline child Play call.",
+    errorMessage: "ctx.runPlay key must be a non-empty string."
+  },
+  "ctx.runPlay.playRef": {
+    schema: _typebox.Type.Union([
+      _typebox.Type.String({ minLength: 1 }),
+      _typebox.Type.Union([
+        _typebox.Type.Object(
+          { playName: _typebox.Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        ),
+        _typebox.Type.Object(
+          { name: _typebox.Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        )
+      ])
+    ]),
+    fixtures: {
+      valid: "prebuilt/company-lookup",
+      invalid: {},
+      absent: void 0,
+      unresolved: { expression: "playRef" },
+      edition1: { name: "company-lookup" }
+    },
+    referenceType: "string | PlayReferenceLike",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Child Play name or typed Play definition handle.",
+    errorMessage: "ctx.runPlay playRef must be a non-empty Play name or definition handle."
+  },
+  "ctx.runPlay.input": {
+    schema: _typebox.Type.Record(_typebox.Type.String(), _typebox.Type.Unknown()),
+    fixtures: {
+      valid: { domain: "example.com" },
+      invalid: "example.com",
+      absent: void 0,
+      unresolved: "childInput",
+      edition1: {}
+    },
+    referenceType: "Record<string, unknown>",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Scalar input object submitted to the child Play.",
+    errorMessage: "ctx.runPlay input must be an object."
+  },
+  "ctx.runPlay.options.description": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich the company.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Run child."
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Non-empty purpose for one inline child Play call.",
+    errorMessage: "ctx.runPlay options.description must be non-empty."
+  },
+  "ctx.runPlay.options.execution": {
+    schema: _typebox.Type.Literal("inline"),
+    fixtures: {
+      valid: "inline",
+      invalid: "child-workflow",
+      absent: void 0,
+      unresolved: { expression: "execution" },
+      edition1: "inline"
+    },
+    referenceType: "'inline'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Child composition strategy. Only inline is supported.",
+    errorMessage: 'ctx.runPlay execution must be "inline".'
+  },
+  "ctx.runPlay.options.timeoutMs": {
+    schema: _typebox.Type.Undefined(),
+    fixtures: {
+      valid: void 0,
+      invalid: 1e3,
+      absent: void 0,
+      unresolved: { expression: "timeoutMs" },
+      edition1: void 0
+    },
+    referenceType: "never",
+    required: false,
+    resolution: "unsupported",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Unsupported legacy child-workflow timeout.",
+    errorMessage: "ctx.runPlay timeoutMs is unsupported because child Plays execute inline."
+  },
+  "ctx.runPlayAsync.key": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "request-approval",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "callKey" },
+      edition1: "request-approval"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Stable identity for one independent child Play Run.",
+    errorMessage: "ctx.runPlayAsync key must be a non-empty string."
+  },
+  "ctx.runPlayAsync.playRef": {
+    schema: _typebox.Type.Union([
+      _typebox.Type.String({ minLength: 1 }),
+      _typebox.Type.Union([
+        _typebox.Type.Object(
+          { playName: _typebox.Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        ),
+        _typebox.Type.Object(
+          { name: _typebox.Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        )
+      ])
+    ]),
+    fixtures: {
+      valid: "request-approval",
+      invalid: {},
+      absent: void 0,
+      unresolved: { expression: "playRef" },
+      edition1: "request-approval"
+    },
+    referenceType: "string | PlayReferenceLike",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Independently published scalar child Play name or strongly typed definition handle.",
+    errorMessage: "ctx.runPlayAsync playRef must be a non-empty Play name or definition handle."
+  },
+  "ctx.runPlayAsync.input": {
+    schema: _typebox.Type.Record(_typebox.Type.String(), _typebox.Type.Unknown()),
+    fixtures: {
+      valid: { draftId: "draft-1" },
+      invalid: "draft-1",
+      absent: void 0,
+      unresolved: "childInput",
+      edition1: {}
+    },
+    referenceType: "Record<string, unknown>",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Scalar input object submitted to the independent child Run.",
+    errorMessage: "ctx.runPlayAsync input must be an object."
+  },
+  "ctx.runPlayAsync.options.description": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Request approval.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Request approval."
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Non-empty purpose for one independent child Play Run.",
+    errorMessage: "ctx.runPlayAsync options.description must be non-empty."
+  },
+  "runtime.timeout": {
+    schema: _typebox.Type.String({ pattern: "^\\d+\\s*[mh]$" }),
+    fixtures: {
+      valid: "90m",
+      invalid: "90s",
+      absent: void 0,
+      unresolved: { expression: "timeout" },
+      edition1: "90m"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Play-level sandbox deadline. The default is 30m; use a static duration such as 90m or 2h, up to 4h.",
+    errorMessage: 'runtime.timeout must be a static duration such as "90m" or "2h".'
+  },
+  "runtime.size": {
+    schema: _typebox.Type.Literal("standard"),
+    fixtures: {
+      valid: "standard",
+      invalid: "large",
+      absent: void 0,
+      unresolved: { expression: "size" },
+      edition1: "standard"
+    },
+    referenceType: "'standard'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Deepline-managed sandbox size. Only standard is supported.",
+    errorMessage: 'runtime.size must be the static literal "standard".'
+  },
+  "ctx.customerDb.query.statement": {
+    schema: _typebox.Type.Union([
+      _typebox.Type.String({ minLength: 1 }),
+      _typebox.Type.Object(
+        {
+          kind: _typebox.Type.Optional(_typebox.Type.Literal("sql.query")),
+          text: _typebox.Type.String({ minLength: 1 }),
+          values: _typebox.Type.Optional(_typebox.Type.Array(_typebox.Type.Unknown(), { maxItems: 0 }))
+        },
+        { additionalProperties: false }
+      )
+    ]),
+    fixtures: {
+      valid: { kind: "sql.query", text: "select 1", values: [] },
+      invalid: { kind: "sql.query", text: "select $1", values: [1] },
+      absent: void 0,
+      unresolved: { expression: "statement" },
+      edition1: "select 1"
+    },
+    referenceType: "SqlQuery",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "One non-empty Customer DB SQL string; the deprecated SqlQuery object is accepted only without parameter values.",
+    errorMessage: "ctx.customerDb.query statement must be a non-empty SQL string. Deprecated SqlQuery objects cannot contain parameter values."
+  },
+  "ctx.customerDb.query.options.id": {
+    schema: _typebox.Type.String({ pattern: "\\S" }),
+    fixtures: {
+      valid: "customer-report-read",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "operationId" },
+      edition1: "query"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Stable operation identity for Customer DB query recovery.",
+    errorMessage: "ctx.customerDb.query options.id must be a non-empty stable string."
+  },
+  "ctx.customerDb.query.options.staleAfterSeconds": {
+    schema: _typebox.Type.Literal(0),
+    fixtures: {
+      valid: 0,
+      invalid: 1,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: 0
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Customer DB queries always execute with freshness 0.",
+    errorMessage: "Customer DB queries must use staleAfterSeconds: 0."
+  },
+  "ctx.customerDb.query.options.maxRows": {
+    schema: _typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 100,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "maxRows" },
+      edition1: 100
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Positive whole-number Customer DB response row limit.",
+    errorMessage: "ctx.customerDb.query options.maxRows must be a positive whole number."
+  },
+  "ctx.customerDb.query.options.timeoutMs": {
+    schema: _typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 1e3,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "timeoutMs" },
+      edition1: 1e3
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Positive whole-number Customer DB timeout in milliseconds.",
+    errorMessage: "ctx.customerDb.query options.timeoutMs must be a positive whole number of milliseconds."
+  },
+  "ctx.tool.key": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "key" },
+      edition1: "tool"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Stable receipt identity for the tool shorthand.",
+    errorMessage: "ctx.tool key must be a non-empty string."
+  },
+  "ctx.tool.tool": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "openmart_enrich_company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "tool" },
+      edition1: "openmart_enrich_company"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Integration tool id for the tool shorthand.",
+    errorMessage: "ctx.tool tool must be a non-empty tool id."
+  },
+  "ctx.tool.input": {
+    schema: _typebox.Type.Record(_typebox.Type.String(), _typebox.Type.Unknown()),
+    fixtures: {
+      valid: { domain: "example.com" },
+      invalid: "example.com",
+      absent: void 0,
+      unresolved: "toolInput",
+      edition1: {}
+    },
+    referenceType: "Record<string, unknown>",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Tool-specific input object for the shorthand.",
+    errorMessage: "ctx.tool input must be an object."
+  },
+  "ctx.tool.options.description": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich the company.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Run tool."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Non-empty purpose for the tool shorthand.",
+    errorMessage: "ctx.tool options.description must be non-empty."
+  },
+  "ctx.runSteps.options.description": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Score the account.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Run steps."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Non-empty purpose for a reusable step program.",
+    errorMessage: "ctx.runSteps options.description must be non-empty."
+  },
+  "ctx.runSteps.options.staleAfterSeconds": {
+    schema: _typebox.Type.Union([_typebox.Type.Null(), _typebox.Type.Integer({ minimum: 0 })]),
+    fixtures: {
+      valid: 0,
+      invalid: -1,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: null
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
+    errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
+  },
+  "ctx.sleep.ms": {
+    schema: _typebox.Type.Integer({ minimum: 0 }),
+    fixtures: {
+      valid: 0,
+      invalid: -1,
+      absent: void 0,
+      unresolved: { expression: "delayMs" },
+      edition1: 1e3
+    },
+    referenceType: "number",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Non-negative whole-number sleep duration in milliseconds.",
+    errorMessage: "ctx.sleep ms must be a non-negative whole number."
+  },
+  "ctx.fetch.url": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "https://example.com",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "url" },
+      edition1: "https://example.com"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_fetch_secret_requires_tls",
+    description: "HTTP request URL. Secret authentication requires HTTPS.",
+    errorMessage: "ctx.fetch URL must be a non-empty URL string."
+  },
+  "ctx.fetch.init.method": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "GET",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "method" },
+      edition1: "GET"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_fetch_idempotency_required",
+    description: "HTTP method. Mutating methods require an Idempotency-Key.",
+    errorMessage: "ctx.fetch method must be a non-empty string."
+  },
+  "ctx.fetch.init.headers.Idempotency-Key": {
+    schema: _typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "contact-123-update",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "idempotencyKey" },
+      edition1: "contact-123-update"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_fetch_idempotency_required",
+    description: "Required for mutating HTTP methods. The provider must support idempotency, and the same key must be retained across retries and replay.",
+    errorMessage: "Idempotency-Key must be a non-empty string when provided."
+  }
+};
+var UnsupportedPlayAuthoringContractEditionError = class extends Error {
+  constructor(value) {
+    super(
+      `Unsupported Play authoring contract edition ${String(value)}. Supported editions: ${SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS.join(", ")}.`
+    );
+    this.name = "UnsupportedPlayAuthoringContractEditionError";
+  }
+};
+var PlayAuthoringContractViolationError = class extends Error {
+  constructor(path, code, detail, hint) {
+    super(`[${code} path=${path}] ${detail}`);
+    this.path = path;
+    this.code = code;
+    this.detail = detail;
+    this.hint = hint;
+    this.name = "PlayAuthoringContractViolationError";
+  }
+};
+var PlayAuthoringFieldValidationError = class extends PlayAuthoringContractViolationError {
+  constructor(path, code, message) {
+    super(path, code, message);
+    this.name = "PlayAuthoringFieldValidationError";
+  }
+};
+function normalizePlayAuthoringContractEdition(value) {
+  const edition = _nullishCoalesce(value, () => ( LEGACY_PLAY_AUTHORING_CONTRACT_EDITION));
+  if (!SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS.includes(
+    edition
+  )) {
+    throw new UnsupportedPlayAuthoringContractEditionError(edition);
+  }
+  return edition;
+}
+function validatePlayAuthoringField(path, value) {
+  const definition = PLAY_AUTHORING_FIELD_REGISTRY[path];
+  if (_value.Value.Check(definition.schema, value)) return;
+  throw new PlayAuthoringFieldValidationError(
+    path,
+    definition.issueCode,
+    definition.errorMessage
+  );
+}
+function cloudReferenceType(path) {
+  return PLAY_AUTHORING_FIELD_REGISTRY[path].referenceType;
+}
+var PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
+  `export type DurableCallStaleAfterSeconds = ${cloudReferenceType("ctx.tools.execute.staleAfterSeconds")};`,
+  `export type PlayRuntimeTimeoutMs = ${cloudReferenceType("ctx.tools.execute.timeoutMs")};`,
+  `export type PlayReceiptWaitMs = ${cloudReferenceType("ctx.tools.execute.receiptWaitMs")};`,
+  `export type SqlListenerOperation = ${cloudReferenceType("bindings.sqlListeners[].operations[]")};`,
+  "export type SqlListenerFilterScalar = string | number | boolean | null;",
+  `export type SqlListenerFilterOperator = { eq?: ${cloudReferenceType("bindings.sqlListeners[].where.*.*.eq")}; neq?: ${cloudReferenceType("bindings.sqlListeners[].where.*.*.neq")}; in?: ${cloudReferenceType("bindings.sqlListeners[].where.*.*.in")}; notIn?: ${cloudReferenceType("bindings.sqlListeners[].where.*.*.notIn")}; isNull?: ${cloudReferenceType("bindings.sqlListeners[].where.*.*.isNull")}; isNotNull?: ${cloudReferenceType("bindings.sqlListeners[].where.*.*.isNotNull")}; ilike?: ${cloudReferenceType("bindings.sqlListeners[].where.*.*.ilike")} };`,
+  `export type SqlListenerWhere = { before?: ${cloudReferenceType("bindings.sqlListeners[].where.before")}; after?: ${cloudReferenceType("bindings.sqlListeners[].where.after")} };`,
+  `export type SqlListenerDeclaration = { id: ${cloudReferenceType("bindings.sqlListeners[].id")}; tool: ${cloudReferenceType("bindings.sqlListeners[].tool")}; stream: ${cloudReferenceType("bindings.sqlListeners[].stream")}; operations?: readonly SqlListenerOperation[]; where?: SqlListenerWhere };`,
+  "export type SqlListenerEvent<T extends object = Record<string, unknown>> = { tool: string; stream: string; operation: SqlListenerOperation; before: T | null; after: T | null; changedAt: string; metadata: { outboxId: string; listenerId: string; table: string } };",
+  "export type SqlQuery = string | { kind?: 'sql.query'; text: string; values?: readonly unknown[] };",
+  "export type ToolExecutionRequest<K extends string> = {",
+  `  readonly id: ${cloudReferenceType("ctx.tools.execute.id")};`,
+  `  readonly tool: ${cloudReferenceType("ctx.tools.execute.tool")};`,
+  `  readonly input: ${cloudReferenceType("ctx.tools.execute.input")};`,
+  `  readonly description?: ${cloudReferenceType("ctx.tools.execute.description")};`,
+  `  readonly force?: ${cloudReferenceType("ctx.tools.execute.force")};`,
+  "  readonly staleAfterSeconds?: DurableCallStaleAfterSeconds;",
+  "  readonly timeoutMs?: PlayRuntimeTimeoutMs;",
+  "  readonly receiptWaitMs?: PlayReceiptWaitMs;",
+  "};",
+  "export type PlayCronInput<TInput> = TInput extends readonly unknown[] ? never : TInput extends object ? TInput : never;",
+  "export type PlayBindings<TInput = Record<string, unknown>> = {",
+  `  displayName?: ${cloudReferenceType("displayName")};`,
+  `  description?: ${cloudReferenceType("description")};`,
+  `  compatibility?: { authoringContract?: ${cloudReferenceType("compatibility.authoringContract")}; toolErrorSchemaVersion?: ${cloudReferenceType("compatibility.toolErrorSchemaVersion")}; toolResponseReceiptRevision?: ${cloudReferenceType("compatibility.toolResponseReceiptRevision")} };`,
+  `  inline?: ${cloudReferenceType("inline")};`,
+  `  billing?: { maxCreditsPerRun?: ${cloudReferenceType("billing.maxCreditsPerRun")} };`,
+  `  runtime?: { timeout?: ${cloudReferenceType("runtime.timeout")}; size?: ${cloudReferenceType("runtime.size")} };`,
+  `  webhook?: { hmac?: { algorithm?: ${cloudReferenceType("bindings.webhook.hmac.algorithm")}; header?: ${cloudReferenceType("bindings.webhook.hmac.header")}; signaturePrefix?: ${cloudReferenceType("bindings.webhook.hmac.signaturePrefix")}; secretEnv: ${cloudReferenceType("bindings.webhook.hmac.secretEnv")} }; auth?: { type: ${cloudReferenceType("bindings.webhook.auth.type")}; headerFamily: ${cloudReferenceType("bindings.webhook.auth.headerFamily")}; signingSecrets: readonly ${cloudReferenceType("bindings.webhook.auth.signingSecrets[]")}[]; toleranceSeconds?: ${cloudReferenceType("bindings.webhook.auth.toleranceSeconds")} } };`,
+  `  cron?: { schedule: ${cloudReferenceType("bindings.cron.schedule")}; timezone?: ${cloudReferenceType("bindings.cron.timezone")}; input?: PlayCronInput<TInput> };`,
+  "  sqlListeners?: readonly SqlListenerDeclaration[];",
+  `  secrets?: readonly ${cloudReferenceType("bindings.secrets[]")}[];`,
+  "};",
+  "declare const SECRET_HANDLE_BRAND: unique symbol;",
+  "declare const SECRET_PROMISE_BRAND: unique symbol;",
+  "export type SecretHandle = { readonly [SECRET_HANDLE_BRAND]: never; readonly name: string; toString(): string; toJSON(): never };",
+  "export type SecretPromise = Promise<string> & { readonly [SECRET_PROMISE_BRAND]: never };",
+  "export type SecretValue = SecretHandle;",
+  "export type SecretAuth = { readonly kind: 'bearer' | 'header'; readonly secret: string | SecretPromise | SecretHandle; readonly header?: string };",
+  "export type SecretAuthInput = SecretAuth | readonly SecretAuth[];",
+  "export type PlayInputContract<TInput> = { readonly schema: Record<string, unknown>; readonly __inputType?: TInput };",
+  "export type PlayReturnObject = Record<string, unknown> & { readonly _metadata?: never };",
+  "export type CsvRenameMap = Record<string, string | readonly string[]>;",
+  "export type FileInput<TMetadata = unknown> = string & { readonly __deeplineFileInputMetadata?: TMetadata };",
+  "export type CsvInput<TRow extends object = Record<string, unknown>> = FileInput<{ readonly kind: 'csv'; readonly row: TRow }>;",
+  "export type ColumnMap<TRow extends object> = { [K in keyof TRow & string]?: string | readonly string[] };",
+  `export type CsvOptions = { description?: ${cloudReferenceType("ctx.csv.options.description")}; columns?: ${cloudReferenceType("ctx.csv.options.columns")}; rename?: ${cloudReferenceType("ctx.csv.options.rename")}; required?: ${cloudReferenceType("ctx.csv.options.required")} };`,
+  "export type PlayCallExecution = 'inline';",
+  `export type PlayCallOptions = { description: ${cloudReferenceType("ctx.runPlay.options.description")}; execution?: ${cloudReferenceType("ctx.runPlay.options.execution")}; timeoutMs?: ${cloudReferenceType("ctx.runPlay.options.timeoutMs")} };`,
+  `export type PlayAsyncCallOptions = { description: ${cloudReferenceType("ctx.runPlayAsync.options.description")} };`,
+  "declare const PLAY_RUN_ID_BRAND: unique symbol;",
+  "export type PlayRunId = string & { readonly [PLAY_RUN_ID_BRAND]: 'PlayRunId' };",
+  "export type AsyncPlayRunRef = Readonly<{ runId: PlayRunId }>;",
+  `export type RuntimeStepOptions = { semanticKey?: ${cloudReferenceType("ctx.step.semanticKey")}; staleAfterSeconds?: ${cloudReferenceType("ctx.step.staleAfterSeconds")} };`,
+  `export type FetchOptions = { staleAfterSeconds?: ${cloudReferenceType("ctx.fetch.staleAfterSeconds")}; transient?: boolean };`,
+  "export type CallFreshnessMetadata = { requestedStaleAfterSeconds: number | null; effectiveStaleAfterSeconds: number | null; source: 'executed' | 'operation_recovery' | 'reusable_result' | 'live_observation'; resultAgeMs: number; completedAt: number; operationReceiptKey?: string; unavailableReason?: string };",
+  "export type ToolResultExecutionMetadata = { idempotent: true; cached: boolean; source: 'live' | 'checkpoint' | 'cache' | 'in_flight' | 'source_run'; cacheKey?: string; receiptRole?: 'owner' | 'follower'; receiptKey?: string; resultReceiptKey?: string; attachedToReceiptKey?: string; freshness?: CallFreshnessMetadata; completedAt?: number };",
+  "export type PlayFetchResponse = { freshness?: CallFreshnessMetadata; ok: boolean; status: number; statusText: string; url: string; headers: Record<string, string>; bodyText: string; json: unknown | null };",
+  "export declare class CtxFetchAmbiguousWriteError extends Error { readonly code: 'CTX_FETCH_WRITE_OUTCOME_UNKNOWN'; readonly outcome: 'unknown'; readonly method: string; readonly origin: string; }",
+  "export declare class CtxFetchHttpError extends Error { readonly code: 'CTX_FETCH_HTTP_ERROR'; readonly response: PlayFetchResponse; readonly status: number; readonly statusText: string; readonly url: string; readonly headers: Record<string, string>; readonly bodyText: string; readonly json: unknown | null; }",
+  "export type StepResolver<Row, Value> = (row: Row, ctx: DeeplinePlayRuntimeContext, index: number, previousCell?: PreviousCell<Value>) => Value | Promise<Value>;",
+  "export type DatasetColumnRunInput<Row, Value> = { readonly row: Row; readonly ctx: DeeplinePlayRuntimeContext; readonly index: number; readonly previousCell?: PreviousCell<Value> };",
+  "export type DatasetColumnDefinition<Row, Value> = { readonly run: (input: DatasetColumnRunInput<Row, Value>) => Value | Promise<Value>; readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean> };",
+  "export type ConditionalStepResolver<Row, Value, Else = null> = { readonly kind: 'conditional'; readonly when: (row: Row, index: number) => boolean | Promise<boolean>; readonly run: StepResolver<Row, Value>; readonly elseValue: Else; else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>; };",
+  "export type StepOptions<Row, Value = unknown> = { readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: DurableCallStaleAfterSeconds };",
+  "export type StepProgramOptions = { readonly continueOnProviderUnavailable?: boolean };",
+  "export type StepProgram<Input, Output, Return = Output> = { readonly kind: 'steps'; readonly steps: readonly PlayStepProgramStep[]; readonly returnResolver?: StepResolver<Output, Return>; readonly continueOnProviderUnavailable?: boolean; readonly __inputType?: (input: Input) => void; step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>; step<Name extends string, Value, Options extends StepOptions<Output, Value>>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: Options): StepProgram<Input, Output & Record<Name, 'runIf' extends keyof Options ? Value | null : Value>, Return>; return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>; };",
+  "export type StepProgramResolver<Input, Return> = { readonly kind: 'steps'; readonly steps: readonly PlayStepProgramStep[]; readonly returnResolver?: StepResolver<never, Return>; readonly __inputType?: (input: Input) => void };",
+  "export type RunnableStepProgram<Input, Return> = Pick<StepProgram<Input, never, Return>, 'kind' | 'steps' | 'returnResolver' | '__inputType'>;",
+  "export type RunnableColumnStepProgram<Return> = Pick<StepProgramResolver<unknown, Return>, 'kind' | 'steps' | 'returnResolver'>;",
+  "export type PlayStepProgramStep = { readonly name: string; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: DurableCallStaleAfterSeconds; readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown> };",
+  "export type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | RunnableColumnStepProgram<Value>;",
+  "export type StepProgramOutput<TProgram> = TProgram extends StepProgram<unknown, infer Output, unknown> ? Output : never;",
+  "export type DatasetRowKey<InputRow extends object> = (keyof InputRow & string) | readonly (keyof InputRow & string)[] | ((row: InputRow, index: number) => string | number | readonly unknown[]);",
+  "export type DatasetDefinitionOptions<InputRow extends object> = { key?: DatasetRowKey<InputRow> };",
+  `export type DatasetRunOptions<InputRow extends object> = { description?: ${cloudReferenceType("ctx.dataset.run.description")}; key?: DatasetRowKey<InputRow>; rowIdentity?: ${cloudReferenceType("ctx.dataset.run.rowIdentity")}; onRowError?: ${cloudReferenceType("ctx.dataset.run.onRowError")}; mode?: ${cloudReferenceType("ctx.dataset.run.mode")}; undrawnColumns?: ${cloudReferenceType("ctx.dataset.run.undrawnColumns")} };`,
+  "export type DatasetBuilder<InputRow extends object, OutputRow extends object> = {",
+  "  withColumn<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;",
+  "  withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value> & { readonly runIf: (row: OutputRow, index: number) => boolean | Promise<boolean> }): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;",
+  "  withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;",
+  "  withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | RunnableColumnStepProgram<Value>, options: StepOptions<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;",
+  "  withColumns<ProgramOutput extends OutputRow, Return>(program: StepProgram<OutputRow, ProgramOutput, Return>): DatasetBuilder<InputRow, ProgramOutput>;",
+  "  step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;",
+  "  run(options?: DatasetRunOptions<InputRow>): Promise<PlayDataset<OutputRow>>;",
+  "};",
+  "export type PlayReferenceLike<TInput extends Record<string, unknown> = Record<string, unknown>> = ({ readonly playName: string; readonly name?: string } | { readonly name: string; readonly playName?: string }) & { readonly __inputType?: TInput };",
+  "export type BillingBenefitValues = { quickenrichUnlimited: { enabled: boolean; requestsPerMinute: number } };",
+  "export type BillingEntitlements = { org_id: string; as_of: number; plan: { sku: string; name: string; catalog_revision: string | null; included_credits: number; interval: 'month' | 'year' | null } | null; benefits: { quickenrichUnlimited?: { status: 'active' | 'past_due'; value: BillingBenefitValues['quickenrichUnlimited']; expiresAt?: number } }; effective_limits: { quickenrichUnlimited?: { baseline: number; effective: number; source: 'plan' | 'override'; override_expires_at?: number } } };",
+  "export interface DeeplinePlayRuntimeContext {",
+  "  billing: { entitlements(): Promise<BillingEntitlements> };",
+  "  csv<T = Record<string, unknown>>(path: string | CsvInput<T & object>, options?: CsvOptions): Promise<PlayDataset<T>>;",
+  "  dataset<TSource extends PlayDatasetInput<object>>(key: string, items: TSource): DatasetBuilder<PlayDatasetRow<TSource> & object, PlayDatasetRow<TSource> & object>;",
+  "  map<TSource extends PlayDatasetInput<object>>(key: string, items: TSource, options?: DatasetDefinitionOptions<PlayDatasetRow<TSource> & object>): never;",
+  "  readonly run: { readonly id: string };",
+  `  runSteps<TInput extends Record<string, unknown>, TOutput>(program: RunnableStepProgram<TInput, TOutput>, input: TInput, options?: { description?: ${cloudReferenceType("ctx.runSteps.options.description")}; staleAfterSeconds?: ${cloudReferenceType("ctx.runSteps.options.staleAfterSeconds")} }): Promise<TOutput>;`,
+  "  tools: { execute<K extends string>(request: ToolExecutionRequest<K>): Promise<ToolExecutionOutput<K>> };",
+  `  customerDb: { query<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: SqlQuery, options?: { id?: ${cloudReferenceType("ctx.customerDb.query.options.id")}; staleAfterSeconds?: ${cloudReferenceType("ctx.customerDb.query.options.staleAfterSeconds")}; maxRows?: ${cloudReferenceType("ctx.customerDb.query.options.maxRows")}; timeoutMs?: ${cloudReferenceType("ctx.customerDb.query.options.timeoutMs")} }): Promise<TRow[]> };`,
+  `  tool<K extends string>(key: ${cloudReferenceType("ctx.tool.key")}, toolId: K, input: ${cloudReferenceType("ctx.tool.input")}, options?: { description?: ${cloudReferenceType("ctx.tool.options.description")}; staleAfterSeconds?: DurableCallStaleAfterSeconds }): Promise<ToolExecutionOutput<K>>;`,
+  "  step<T>(id: string, run: () => T | Promise<T>, options?: RuntimeStepOptions): Promise<T>;",
+  "  fetch(key: string, url: string | URL, init?: RequestInit & { headers?: HeadersInit & { 'Idempotency-Key'?: string; 'X-Idempotency-Key'?: string }; auth?: SecretAuthInput }, options?: FetchOptions): Promise<PlayFetchResponse>;",
+  "  secrets: { get(name: string): SecretPromise; bearer(secret: string | SecretPromise | SecretHandle): SecretAuth; header(header: string, secret: string | SecretPromise | SecretHandle): SecretAuth };",
+  `  runPlay<TOutput = unknown>(key: string, playRef: ${cloudReferenceType("ctx.runPlay.playRef")}, input: ${cloudReferenceType("ctx.runPlay.input")}, options: PlayCallOptions): Promise<TOutput>;`,
+  "  runPlayAsync<TInput extends Record<string, unknown>>(key: string, playRef: PlayReferenceLike<TInput>, input: NoInfer<TInput>, options: PlayAsyncCallOptions): Promise<AsyncPlayRunRef>;",
+  "  runPlayAsync(key: string, playRef: string, input: Record<string, unknown>, options: PlayAsyncCallOptions): Promise<AsyncPlayRunRef>;",
+  "  log(message: string, options?: { level?: 'debug' | 'info' | 'warn' | 'error'; context?: Readonly<Record<string, string | number | boolean>> }): void;",
+  `  sleep(ms: ${cloudReferenceType("ctx.sleep.ms")}): Promise<void>;`,
+  "}",
+  "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; displayName?: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings<TInput>; billing?: PlayBindings<TInput>['billing']; runtime?: PlayBindings<TInput>['runtime']; compatibility?: PlayBindings<TInput>['compatibility'] };",
+  "export type DefinedPlay<TInput, TOutput extends PlayReturnObject> = ((ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>) & { readonly name: string; readonly __inputType?: TInput; readonly __outputType?: TOutput; readonly bindings?: PlayBindings<TInput>; readonly runtime?: PlayBindings<TInput>['runtime']; readonly compatibility?: PlayBindings<TInput>['compatibility'] };",
+  "export type PlayHandlerInput<THandler> = THandler extends (context: DeeplinePlayRuntimeContext, input: infer TInput) => Promise<PlayReturnObject> ? TInput : never;",
+  "export type PlayHandlerOutput<THandler> = THandler extends (context: DeeplinePlayRuntimeContext, input: unknown) => Promise<infer TOutput extends PlayReturnObject> ? TOutput : never;"
+];
+
 // ../plays/contracts.ts
 var PLAY_ARTIFACT_VERSION = _chunkOG64RBACjs.CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION;
+var UnsupportedPlayToolErrorSchemaVersionError = class extends Error {
+  constructor(value) {
+    super(
+      `Unsupported Play tool error schema version ${String(value)}. Supported versions: ${_chunkPPDBRJRWjs.SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS.join(", ")}.`
+    );
+    this.name = "UnsupportedPlayToolErrorSchemaVersionError";
+  }
+};
+var InvalidPlayContractCompatibilityError = class extends Error {
+  constructor(message = "Play artifact compatibility must be an object.") {
+    super(message);
+    this.name = "InvalidPlayContractCompatibilityError";
+  }
+};
+function normalizePlayContractCompatibility(compatibility) {
+  if (!compatibility || typeof compatibility !== "object" || Array.isArray(compatibility)) {
+    throw new InvalidPlayContractCompatibilityError();
+  }
+  const requestedToolErrorSchemaVersion = _nullishCoalesce(compatibility.toolErrorSchemaVersion, () => ( _chunkPPDBRJRWjs.TOOL_EXECUTION_ERROR_SCHEMA_VERSION));
+  if (compatibility.datasetRowInput !== void 0 && compatibility.datasetRowInput !== "current_run") {
+    throw new InvalidPlayContractCompatibilityError(
+      `Unsupported dataset row input policy ${String(compatibility.datasetRowInput)}.`
+    );
+  }
+  if (!_chunkPPDBRJRWjs.SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS.includes(
+    requestedToolErrorSchemaVersion
+  )) {
+    throw new UnsupportedPlayToolErrorSchemaVersionError(
+      requestedToolErrorSchemaVersion
+    );
+  }
+  let toolResponseContract;
+  let toolResponseReceiptRevision;
+  try {
+    toolResponseContract = _chunkE4CABWXLjs.normalizeToolResponseContract.call(void 0, 
+      compatibility.toolResponseContract
+    );
+    toolResponseReceiptRevision = _chunkE4CABWXLjs.normalizeToolResponseReceiptRevision.call(void 0, 
+      compatibility.toolResponseReceiptRevision
+    );
+  } catch (error) {
+    if (error instanceof _chunkE4CABWXLjs.UnsupportedToolResponseContractError || error instanceof _chunkE4CABWXLjs.InvalidToolResponseReceiptRevisionError) {
+      throw new InvalidPlayContractCompatibilityError(error.message);
+    }
+    throw error;
+  }
+  return {
+    ...compatibility,
+    toolErrorSchemaVersion: _chunkPPDBRJRWjs.TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+    toolResponseContract,
+    ...toolResponseReceiptRevision ? { toolResponseReceiptRevision } : {},
+    authoringContractEdition: normalizePlayAuthoringContractEdition(
+      compatibility.authoringContractEdition
+    )
+  };
+}
 function buildPlayContractCompatibility(input) {
   return {
     artifactVersion: PLAY_ARTIFACT_VERSION,
-    runtimeBackend: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _ => _.runtimeBackend]), () => ( null)),
-    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _2 => _2.toolErrorSchemaVersion]), () => ( _chunk7P5AA3SNjs.TOOL_EXECUTION_ERROR_SCHEMA_VERSION)),
-    authoringContractEdition: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _3 => _3.authoringContractEdition]), () => ( _chunkZ4VNJOF7js.PLAY_AUTHORING_CONTRACT_EDITION)),
-    toolResponseContract: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _4 => _4.toolResponseContract]), () => ( _chunkS6R3OX7Bjs.RAW_V2_TOOL_RESPONSE_CONTRACT)),
-    toolResponseReceiptRevision: _chunkS6R3OX7Bjs.normalizeToolResponseReceiptRevision.call(void 0, 
-      _nullishCoalesce(_optionalChain([input, 'optionalAccess', _5 => _5.toolResponseReceiptRevision]), () => ( _chunkS6R3OX7Bjs.RAW_V2_TOOL_RESPONSE_RECEIPT_REVISION))
+    ..._optionalChain([input, 'optionalAccess', _ => _.datasetRowInput]) ? { datasetRowInput: input.datasetRowInput } : {},
+    runtimeBackend: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _2 => _2.runtimeBackend]), () => ( null)),
+    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _3 => _3.toolErrorSchemaVersion]), () => ( _chunkPPDBRJRWjs.TOOL_EXECUTION_ERROR_SCHEMA_VERSION)),
+    authoringContractEdition: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _4 => _4.authoringContractEdition]), () => ( PLAY_AUTHORING_CONTRACT_EDITION)),
+    toolResponseContract: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _5 => _5.toolResponseContract]), () => ( _chunkE4CABWXLjs.RAW_V2_TOOL_RESPONSE_CONTRACT)),
+    toolResponseReceiptRevision: _chunkE4CABWXLjs.normalizeToolResponseReceiptRevision.call(void 0, 
+      _nullishCoalesce(_optionalChain([input, 'optionalAccess', _6 => _6.toolResponseReceiptRevision]), () => ( _chunkE4CABWXLjs.RAW_V2_TOOL_RESPONSE_RECEIPT_REVISION))
     )
   };
 }
@@ -119,7 +1924,7 @@ function isDefinePlayCall(node) {
 }
 function stringLiteralValue(node) {
   const expression = unwrapStaticExpression(node);
-  return _optionalChain([expression, 'optionalAccess', _6 => _6.type]) === "Literal" && typeof expression.value === "string" ? expression.value : null;
+  return _optionalChain([expression, 'optionalAccess', _7 => _7.type]) === "Literal" && typeof expression.value === "string" ? expression.value : null;
 }
 function definePlayName(node) {
   const expression = unwrapStaticExpression(node);
@@ -127,12 +1932,12 @@ function definePlayName(node) {
   const first = unwrapStaticExpression(
     _nullishCoalesce(astArray(expression.arguments)[0], () => ( null))
   );
-  if (_optionalChain([first, 'optionalAccess', _7 => _7.type]) !== "ObjectExpression") return stringLiteralValue(first);
+  if (_optionalChain([first, 'optionalAccess', _8 => _8.type]) !== "ObjectExpression") return stringLiteralValue(first);
   let id = null;
   for (const property of astArray(first.properties)) {
     if (property.type !== "Property" || property.computed) continue;
     const key = isAstNode(property.key) ? property.key : null;
-    const keyName = _nullishCoalesce(getIdentifierName(key), () => ( (_optionalChain([key, 'optionalAccess', _8 => _8.type]) === "Literal" && typeof key.value === "string" ? key.value : null)));
+    const keyName = _nullishCoalesce(getIdentifierName(key), () => ( (_optionalChain([key, 'optionalAccess', _9 => _9.type]) === "Literal" && typeof key.value === "string" ? key.value : null)));
     if (keyName !== "id") continue;
     id = stringLiteralValue(isAstNode(property.value) ? property.value : null);
   }
@@ -209,7 +2014,7 @@ function listPlayFileExports(sourceCode) {
   return exports;
 }
 function canonicalPlayExportName(exportName, exports) {
-  const requested = _optionalChain([exportName, 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]) || PLAY_DEFAULT_EXPORT;
+  const requested = _optionalChain([exportName, 'optionalAccess', _10 => _10.trim, 'call', _11 => _11()]) || PLAY_DEFAULT_EXPORT;
   for (const entry of exports) {
     if (entry.name === requested || entry.aliases.includes(requested)) {
       return entry.name;
@@ -287,7 +2092,7 @@ function parseAttributes(source, line, errors) {
   const validAttributes = MERMAID_NODE_ATTRIBUTES;
   let cursor = 0;
   while (cursor < source.length) {
-    cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _11 => _11.exec, 'call', _12 => _12(source.slice(cursor)), 'optionalAccess', _13 => _13[0], 'access', _14 => _14.length]), () => ( 0));
+    cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _12 => _12.exec, 'call', _13 => _13(source.slice(cursor)), 'optionalAccess', _14 => _14[0], 'access', _15 => _15.length]), () => ( 0));
     if (cursor >= source.length) break;
     ATTRIBUTE.lastIndex = cursor;
     const match = ATTRIBUTE.exec(source);
@@ -330,12 +2135,12 @@ var SHAPE_KINDS = {
 };
 var MERMAID_LABEL_LOOKS_LIKE_SOURCE = /^(?:\[|\{|\(|>)/;
 function parseMermaidNodeAtStart(source) {
-  const leadingWhitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _15 => _15.exec, 'call', _16 => _16(source), 'optionalAccess', _17 => _17[0], 'access', _18 => _18.length]), () => ( 0));
+  const leadingWhitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _16 => _16.exec, 'call', _17 => _17(source), 'optionalAccess', _18 => _18[0], 'access', _19 => _19.length]), () => ( 0));
   const idMatch = MERMAID_NODE_ID.exec(source.slice(leadingWhitespace));
   if (!idMatch) return null;
   const id = idMatch[0];
   let cursor = leadingWhitespace + id.length;
-  cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _19 => _19.exec, 'call', _20 => _20(source.slice(cursor)), 'optionalAccess', _21 => _21[0], 'access', _22 => _22.length]), () => ( 0));
+  cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _20 => _20.exec, 'call', _21 => _21(source.slice(cursor)), 'optionalAccess', _22 => _22[0], 'access', _23 => _23.length]), () => ( 0));
   const shape = MERMAID_NODE_SHAPES.find(
     ([open2]) => source.startsWith(open2, cursor)
   );
@@ -353,7 +2158,7 @@ function parseMermaidNodeAtStart(source) {
         continue;
       }
       if (source[index] !== openingQuote) continue;
-      const whitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _23 => _23.exec, 'call', _24 => _24(source.slice(index + 1)), 'optionalAccess', _25 => _25[0], 'access', _26 => _26.length]), () => ( 0));
+      const whitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _24 => _24.exec, 'call', _25 => _25(source.slice(index + 1)), 'optionalAccess', _26 => _26[0], 'access', _27 => _27.length]), () => ( 0));
       const candidate = index + 1 + whitespace;
       if (source.startsWith(close, candidate)) {
         labelEnd = candidate;
@@ -387,12 +2192,12 @@ function parseShapedMermaidNodes(fragment) {
   const nodes = [];
   let cursor = 0;
   while (cursor < fragment.length) {
-    const identifier = /[A-Za-z][\w-]*/.exec(fragment.slice(cursor));
-    if (!identifier) break;
-    const start = cursor + (_nullishCoalesce(identifier.index, () => ( 0)));
+    const identifier2 = /[A-Za-z][\w-]*/.exec(fragment.slice(cursor));
+    if (!identifier2) break;
+    const start = cursor + (_nullishCoalesce(identifier2.index, () => ( 0)));
     const parsed = parseMermaidNodeAtStart(fragment.slice(start));
-    if (_optionalChain([parsed, 'optionalAccess', _27 => _27.shaped]) || _optionalChain([parsed, 'optionalAccess', _28 => _28.unterminated])) nodes.push(parsed);
-    cursor = start + Math.max(_nullishCoalesce(_optionalChain([parsed, 'optionalAccess', _29 => _29.length]), () => ( identifier[0].length)), 1);
+    if (_optionalChain([parsed, 'optionalAccess', _28 => _28.shaped]) || _optionalChain([parsed, 'optionalAccess', _29 => _29.unterminated])) nodes.push(parsed);
+    cursor = start + Math.max(_nullishCoalesce(_optionalChain([parsed, 'optionalAccess', _30 => _30.length]), () => ( identifier2[0].length)), 1);
   }
   return nodes;
 }
@@ -409,7 +2214,7 @@ function parseEdgeChain(line) {
     remaining = remaining.slice(connector[0].length);
     const next = parseMermaidNodeAtStart(remaining);
     if (!next) return null;
-    labels.push(_optionalChain([connector, 'access', _30 => _30[1], 'optionalAccess', _31 => _31.trim, 'call', _32 => _32()]) || void 0);
+    labels.push(_optionalChain([connector, 'access', _31 => _31[1], 'optionalAccess', _32 => _32.trim, 'call', _33 => _33()]) || void 0);
     nodes.push(next);
     remaining = remaining.slice(next.length);
   }
@@ -433,10 +2238,10 @@ function inferBindingIo(statement) {
     const expression2 = returned[1].replace(/(['"`])(?:\\.|(?!\1).)*\1/g, "");
     IDENTIFIER.lastIndex = 0;
     for (const match of expression2.matchAll(IDENTIFIER)) {
-      const identifier = match[0];
+      const identifier2 = match[0];
       const index = _nullishCoalesce(match.index, () => ( 0));
-      if (JS_WORDS.has(identifier) || expression2[index - 1] === ".") continue;
-      inputs2.add(identifier);
+      if (JS_WORDS.has(identifier2) || expression2[index - 1] === ".") continue;
+      inputs2.add(identifier2);
     }
     return {
       inputs: [...inputs2],
@@ -454,14 +2259,14 @@ function inferBindingIo(statement) {
   const inputs = /* @__PURE__ */ new Set();
   IDENTIFIER.lastIndex = 0;
   for (const match of expression.matchAll(IDENTIFIER)) {
-    const identifier = match[0];
+    const identifier2 = match[0];
     const index = _nullishCoalesce(match.index, () => ( 0));
     const previous = _nullishCoalesce(expression[index - 1], () => ( ""));
-    const next = _nullishCoalesce(expression[index + identifier.length], () => ( ""));
-    if (JS_WORDS.has(identifier) || identifier === output || previous === "." || next === ":" || /^\s*\(/.test(expression.slice(index + identifier.length))) {
+    const next = _nullishCoalesce(expression[index + identifier2.length], () => ( ""));
+    if (JS_WORDS.has(identifier2) || identifier2 === output || previous === "." || next === ":" || /^\s*\(/.test(expression.slice(index + identifier2.length))) {
       continue;
     }
-    inputs.add(identifier);
+    inputs.add(identifier2);
   }
   return {
     inputs: [...inputs],
@@ -490,7 +2295,7 @@ function blockLabel(block) {
 }
 function parseDocflowBlockGraph(mermaidSource, errors) {
   const docLines = mermaidSource.split(/\r?\n/).filter((line) => line.trim() && !line.trim().startsWith("%%"));
-  const direction = _optionalChain([FLOW_START, 'access', _33 => _33.exec, 'call', _34 => _34(_nullishCoalesce(docLines[0], () => ( ""))), 'optionalAccess', _35 => _35[1], 'optionalAccess', _36 => _36.toUpperCase, 'call', _37 => _37()]);
+  const direction = _optionalChain([FLOW_START, 'access', _34 => _34.exec, 'call', _35 => _35(_nullishCoalesce(docLines[0], () => ( ""))), 'optionalAccess', _36 => _36[1], 'optionalAccess', _37 => _37.toUpperCase, 'call', _38 => _38()]);
   if (!direction) {
     errors.push(
       "Docflow must start with `flowchart` or `graph` and direction `LR`, `RL`, `TB`, `TD`, or `BT`."
@@ -542,12 +2347,12 @@ function parseDocflowBlockGraph(mermaidSource, errors) {
           const at = subgraph.memberIds.indexOf(id);
           if (at !== -1) subgraph.memberIds.splice(at, 1);
         }
-        _optionalChain([subgraphStack, 'access', _38 => _38[subgraphStack.length - 1], 'optionalAccess', _39 => _39.memberIds, 'access', _40 => _40.push, 'call', _41 => _41(id)]);
+        _optionalChain([subgraphStack, 'access', _39 => _39[subgraphStack.length - 1], 'optionalAccess', _40 => _40.memberIds, 'access', _41 => _41.push, 'call', _42 => _42(id)]);
       } else if (existing && existing.label !== label) {
         errors.push(`Docflow node "${id}" has conflicting labels.`);
       } else if (!existing) {
         nodes.set(id, { id, label, kind });
-        _optionalChain([subgraphStack, 'access', _42 => _42[subgraphStack.length - 1], 'optionalAccess', _43 => _43.memberIds, 'access', _44 => _44.push, 'call', _45 => _45(id)]);
+        _optionalChain([subgraphStack, 'access', _43 => _43[subgraphStack.length - 1], 'optionalAccess', _44 => _44.memberIds, 'access', _45 => _45.push, 'call', _46 => _46(id)]);
       }
     }
     return sawDeclaration;
@@ -556,7 +2361,7 @@ function parseDocflowBlockGraph(mermaidSource, errors) {
     const opened = SUBGRAPH_OPEN.exec(line);
     if (opened) {
       const id = opened[1];
-      const rawLabel = _nullishCoalesce(_optionalChain([opened, 'access', _46 => _46[2], 'optionalAccess', _47 => _47.trim, 'call', _48 => _48()]), () => ( ""));
+      const rawLabel = _nullishCoalesce(_optionalChain([opened, 'access', _47 => _47[2], 'optionalAccess', _48 => _48.trim, 'call', _49 => _49()]), () => ( ""));
       const label = rawLabel.length >= 2 && (rawLabel.startsWith('"') && rawLabel.endsWith('"') || rawLabel.startsWith("'") && rawLabel.endsWith("'")) ? rawLabel.slice(1, -1) : rawLabel;
       const parent = subgraphStack[subgraphStack.length - 1];
       const subgraph = {
@@ -609,7 +2414,7 @@ function parseDocflowBlockGraph(mermaidSource, errors) {
       const existing = nodes.get(node.id);
       if (!existing) {
         nodes.set(node.id, node);
-        _optionalChain([subgraphStack, 'access', _49 => _49[subgraphStack.length - 1], 'optionalAccess', _50 => _50.memberIds, 'access', _51 => _51.push, 'call', _52 => _52(node.id)]);
+        _optionalChain([subgraphStack, 'access', _50 => _50[subgraphStack.length - 1], 'optionalAccess', _51 => _51.memberIds, 'access', _52 => _52.push, 'call', _53 => _53(node.id)]);
       } else if (existing.label === existing.id && node.label !== node.id) {
         existing.label = node.label;
         existing.kind = node.kind;
@@ -764,7 +2569,7 @@ function playExportSourceRanges(sourceCode) {
     const recordDeclarations = (declaration, exported) => {
       for (const declarator of astArray(declaration.declarations)) {
         const id = isAstNode(declarator.id) ? declarator.id : null;
-        const name = _optionalChain([id, 'optionalAccess', _53 => _53.type]) === "Identifier" && typeof id.name === "string" ? id.name : null;
+        const name = _optionalChain([id, 'optionalAccess', _54 => _54.type]) === "Identifier" && typeof id.name === "string" ? id.name : null;
         if (!name) continue;
         declarations.set(
           name,
@@ -786,7 +2591,7 @@ function playExportSourceRanges(sourceCode) {
       for (const specifier of astArray(statement.specifiers)) {
         const local = isAstNode(specifier.local) ? specifier.local : null;
         const exported = isAstNode(specifier.exported) ? specifier.exported : null;
-        if (_optionalChain([local, 'optionalAccess', _54 => _54.type]) === "Identifier" && typeof local.name === "string" && _optionalChain([exported, 'optionalAccess', _55 => _55.type]) === "Identifier" && typeof exported.name === "string") {
+        if (_optionalChain([local, 'optionalAccess', _55 => _55.type]) === "Identifier" && typeof local.name === "string" && _optionalChain([exported, 'optionalAccess', _56 => _56.type]) === "Identifier" && typeof exported.name === "string") {
           namedExports.set(exported.name, local.name);
         }
       }
@@ -823,7 +2628,7 @@ function projectRecordedArms(block, errors) {
   for (const binding of block.bindings) {
     if (!binding.arm) continue;
     const incoming = block.edges.filter(
-      (edge2) => edge2.to === binding.nodeId && _optionalChain([block, 'access', _56 => _56.nodes, 'access', _57 => _57.get, 'call', _58 => _58(edge2.from), 'optionalAccess', _59 => _59.kind]) === "decision"
+      (edge2) => edge2.to === binding.nodeId && _optionalChain([block, 'access', _57 => _57.nodes, 'access', _58 => _58.get, 'call', _59 => _59(edge2.from), 'optionalAccess', _60 => _60.kind]) === "decision"
     );
     if (incoming.length === 0) {
       errors.push(
@@ -934,7 +2739,7 @@ function parseDocflowBindingsInSource(source, errors, rejectedNodeIds) {
     MERMAID_NODE.lastIndex = 0;
     const mermaidMatch = _nullishCoalesce(MERMAID_NODE.exec(lines[index]), () => ( null));
     if (!mermaidMatch) continue;
-    const annotatedId = _optionalChain([mermaidMatch, 'access', _60 => _60[1], 'optionalAccess', _61 => _61.trim, 'call', _62 => _62()]);
+    const annotatedId = _optionalChain([mermaidMatch, 'access', _61 => _61[1], 'optionalAccess', _62 => _62.trim, 'call', _63 => _63()]);
     if (annotatedId) rejectedNodeIds.add(annotatedId);
     const attributes = parseAttributes(
       _nullishCoalesce(mermaidMatch[2], () => ( "")),
@@ -942,7 +2747,7 @@ function parseDocflowBindingsInSource(source, errors, rejectedNodeIds) {
       errors
     );
     if (!attributes) continue;
-    const id = _optionalChain([(_nullishCoalesce(annotatedId, () => ( attributes.id))), 'optionalAccess', _63 => _63.trim, 'call', _64 => _64()]);
+    const id = _optionalChain([(_nullishCoalesce(annotatedId, () => ( attributes.id))), 'optionalAccess', _64 => _64.trim, 'call', _65 => _65()]);
     if (!id) {
       errors.push(`Docflow annotation on line ${index + 1} requires id:"\u2026".`);
       continue;
@@ -1038,7 +2843,7 @@ function findDocflowBoundStatement(ast, line, lineStarts) {
     const node = pending.pop();
     const bounds = astNodeBounds(node);
     if (bounds && bounds.start < lineEnd && bounds.end > lineStart && statementTypes.has(node.type)) {
-      if (!match || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _65 => _65(match), 'optionalAccess', _66 => _66.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _67 => _67(match), 'optionalAccess', _68 => _68.start]), () => ( 0)))) {
+      if (!match || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _66 => _66(match), 'optionalAccess', _67 => _67.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _68 => _68(match), 'optionalAccess', _69 => _69.start]), () => ( 0)))) {
         match = node;
       }
     }
@@ -1057,7 +2862,7 @@ var DOCFLOW_STATEMENT_TYPES = /* @__PURE__ */ new Set([
   "VariableDeclaration"
 ]);
 function docflowOutputRoot(binding) {
-  const first = _optionalChain([binding, 'access', _69 => _69.outputs, 'optionalAccess', _70 => _70[0]]);
+  const first = _optionalChain([binding, 'access', _70 => _70.outputs, 'optionalAccess', _71 => _71[0]]);
   if (!first) return null;
   const root = first.split(".")[0];
   if (!root || root === "$output") return null;
@@ -1266,8 +3071,220 @@ function resolveDocflowBinding(ast, binding, lineStarts, parents) {
 // ../plays/bundling/limits.ts
 var MAX_PLAY_BUNDLE_BYTES = 30 * 1024 * 1024;
 
+// ../plays/source-authoring-edition.ts
+function unwrap(node) {
+  let current = node;
+  while (current && [
+    "TSAsExpression",
+    "TSSatisfiesExpression",
+    "TSTypeAssertion",
+    "TSNonNullExpression",
+    "ParenthesizedExpression"
+  ].includes(current.type)) {
+    current = isAstNode(current.expression) ? current.expression : null;
+  }
+  return current;
+}
+function identifier(node) {
+  return isAstNode(node) && node.type === "Identifier" && typeof node.name === "string" ? node.name : null;
+}
+function extractPlaySourceAuthoringEdition(ast, exportName = null) {
+  const declarations = /* @__PURE__ */ new Map();
+  const exports = /* @__PURE__ */ new Map();
+  const legacyExports = /* @__PURE__ */ new Map();
+  const definitions = [];
+  const defineAliases = /* @__PURE__ */ new Set();
+  const record = (statement, exported) => {
+    for (const declaration of astArray(statement.declarations)) {
+      const name = identifier(declaration.id);
+      const initializer = isAstNode(declaration.init) ? declaration.init : null;
+      if (!name) continue;
+      declarations.set(
+        name,
+        statement.kind === "const" || isDefinePlayCall(initializer) ? initializer : null
+      );
+      if (initializer && isDefinePlayCall(initializer))
+        definitions.push(initializer);
+      if (exported) exports.set(name, { type: "Identifier", name });
+    }
+  };
+  for (const statement of astArray(ast.body)) {
+    if (statement.type === "ImportDeclaration") {
+      for (const specifier of astArray(statement.specifiers)) {
+        if (specifier.type === "ImportSpecifier" && ["definePlay", "defineWorkflow"].includes(
+          _nullishCoalesce(identifier(specifier.imported), () => ( ""))
+        )) {
+          const name = identifier(specifier.local);
+          if (name) defineAliases.add(name);
+        }
+      }
+    }
+    if (statement.type === "VariableDeclaration") record(statement, false);
+    if (statement.type === "ExportDefaultDeclaration" && isAstNode(statement.declaration)) {
+      exports.set("default", statement.declaration);
+    }
+    if (statement.type === "TSExportAssignment" && isAstNode(statement.expression)) {
+      legacyExports.set("default", statement.expression);
+    }
+    if (statement.type === "ExportNamedDeclaration") {
+      if (isAstNode(statement.source) || statement.exportKind === "type")
+        continue;
+      if (isAstNode(statement.declaration) && statement.declaration.type === "VariableDeclaration") {
+        record(statement.declaration, true);
+      }
+      for (const specifier of astArray(statement.specifiers)) {
+        if (specifier.exportKind === "type") continue;
+        const local2 = identifier(specifier.local);
+        const exported = _nullishCoalesce(identifier(specifier.exported), () => ( (isAstNode(specifier.exported) && specifier.exported.type === "Literal" && typeof specifier.exported.value === "string" ? specifier.exported.value : null)));
+        if (local2 && exported)
+          exports.set(exported, { type: "Identifier", name: local2 });
+      }
+    }
+    if (statement.type === "ExpressionStatement" && isAstNode(statement.expression) && statement.expression.type === "AssignmentExpression") {
+      const left = isAstNode(statement.expression.left) ? statement.expression.left : null;
+      const right = isAstNode(statement.expression.right) ? statement.expression.right : null;
+      if (_optionalChain([left, 'optionalAccess', _72 => _72.type]) === "MemberExpression" && !left.computed && right) {
+        const object = isAstNode(left.object) ? left.object : null;
+        if (identifier(object) === "module" && identifier(left.property) === "exports") {
+          legacyExports.set("default", right);
+        } else if (identifier(object) === "exports" && identifier(left.property) === "default") {
+          legacyExports.set("default", right);
+        }
+      }
+    }
+  }
+  const resolve4 = (node, seen = /* @__PURE__ */ new Set()) => {
+    const value2 = unwrap(node);
+    if (_optionalChain([value2, 'optionalAccess', _73 => _73.type]) === "UnaryExpression" && value2.operator === "void") {
+      const operand = unwrap(isAstNode(value2.argument) ? value2.argument : null);
+      if (_optionalChain([operand, 'optionalAccess', _74 => _74.type]) === "Literal")
+        return { type: "Literal", value: void 0 };
+    }
+    const name = identifier(value2);
+    if (!name) return value2;
+    if (name === "undefined" && !declarations.has(name))
+      return { type: "Literal", value: void 0 };
+    if (seen.has(name)) return null;
+    return resolve4(_nullishCoalesce(declarations.get(name), () => ( null)), new Set(seen).add(name));
+  };
+  const staticKey = (node) => {
+    const value2 = resolve4(node);
+    if (_optionalChain([value2, 'optionalAccess', _75 => _75.type]) === "Literal" && (typeof value2.value === "string" || typeof value2.value === "number")) {
+      return String(value2.value);
+    }
+    if (_optionalChain([value2, 'optionalAccess', _76 => _76.type]) === "TemplateLiteral" && astArray(value2.expressions).length === 0) {
+      const quasi = astArray(value2.quasis)[0];
+      const cooked = _optionalChain([quasi, 'optionalAccess', _77 => _77.value]) && typeof quasi.value === "object" ? quasi.value.cooked : null;
+      return typeof cooked === "string" ? cooked : null;
+    }
+    return null;
+  };
+  const property = (node, key, ancestors = /* @__PURE__ */ new Set()) => {
+    if (!node) return { kind: "absent" };
+    const object = resolve4(node);
+    if (_optionalChain([object, 'optionalAccess', _78 => _78.type]) === "Literal" && object.value == null)
+      return { kind: "absent" };
+    if (_optionalChain([object, 'optionalAccess', _79 => _79.type]) !== "ObjectExpression" || ancestors.has(object))
+      return { kind: "unknown" };
+    const next = new Set(ancestors).add(object);
+    for (const entry of astArray(object.properties).reverse()) {
+      if (entry.type === "SpreadElement") {
+        const spread = property(
+          isAstNode(entry.argument) ? entry.argument : null,
+          key,
+          next
+        );
+        if (spread.kind !== "absent") return spread;
+        continue;
+      }
+      if (entry.type !== "Property") return { kind: "unknown" };
+      const name = entry.computed ? staticKey(isAstNode(entry.key) ? entry.key : null) : _nullishCoalesce(identifier(entry.key), () => ( staticKey(isAstNode(entry.key) ? entry.key : null)));
+      if (name === null) return { kind: "unknown" };
+      if (name !== key) continue;
+      if (entry.kind !== "init" || entry.method) return { kind: "unknown" };
+      return isAstNode(entry.value) ? { kind: "found", value: entry.value } : { kind: "unknown" };
+    }
+    return { kind: "absent" };
+  };
+  const callMarker = (call) => {
+    const args = astArray(call.arguments);
+    const first = resolve4(_nullishCoalesce(args[0], () => ( null)));
+    const objectForm = _optionalChain([first, 'optionalAccess', _80 => _80.type]) === "ObjectExpression" || args.length === 1;
+    const options = objectForm ? _nullishCoalesce(args[0], () => ( null)) : _nullishCoalesce(args[2], () => ( null));
+    const direct = property(options, "compatibility");
+    let compatibility = direct;
+    if (direct.kind === "absent" || direct.kind === "found" && _optionalChain([resolve4, 'call', _81 => _81(direct.value), 'optionalAccess', _82 => _82.type]) === "Literal" && _optionalChain([resolve4, 'call', _83 => _83(direct.value), 'optionalAccess', _84 => _84.value]) == null) {
+      const bindings = objectForm ? property(options, "bindings") : { kind: "absent" };
+      compatibility = bindings.kind === "found" ? property(bindings.value, "compatibility") : bindings;
+    }
+    return compatibility.kind === "found" ? property(compatibility.value, "authoringContract") : compatibility;
+  };
+  const reachesMarker = (node, seen = /* @__PURE__ */ new Set()) => {
+    const value2 = resolve4(node);
+    if (!value2 || seen.has(value2)) return false;
+    seen.add(value2);
+    if ([
+      "FunctionExpression",
+      "ArrowFunctionExpression",
+      "FunctionDeclaration"
+    ].includes(value2.type))
+      return false;
+    if ((isDefinePlayCall(value2) || value2.type === "CallExpression" && defineAliases.has(_nullishCoalesce(identifier(value2.callee), () => ( "")))) && callMarker(value2).kind !== "absent")
+      return true;
+    return Object.values(value2).some(
+      (child) => isAstNode(child) ? reachesMarker(child, seen) : Array.isArray(child) && astArray(child).some((entry) => reachesMarker(entry, seen))
+    );
+  };
+  const requested = _nullishCoalesce(exportName, () => ( "default"));
+  const local = exports.get(requested);
+  const expression = resolve4(
+    _nullishCoalesce(_nullishCoalesce(local, () => ( legacyExports.get(requested))), () => ( (exportName === null ? _nullishCoalesce(definitions[0], () => ( null)) : null)))
+  );
+  if (!expression || expression.type !== "CallExpression") {
+    return {
+      marker: {
+        kind: local && !expression || reachesMarker(expression) ? "unknown" : "absent"
+      },
+      localExport: false
+    };
+  }
+  const recognized = isDefinePlayCall(expression);
+  const marker = callMarker(expression);
+  if (!recognized && marker.kind === "absent" && reachesMarker(expression)) {
+    return { marker: { kind: "unknown" }, localExport: false };
+  }
+  if (marker.kind !== "found") return { marker, localExport: Boolean(local) };
+  if (!recognized) return { marker: { kind: "unknown" }, localExport: false };
+  const value = resolve4(marker.value);
+  return {
+    marker: _optionalChain([value, 'optionalAccess', _85 => _85.type]) === "Literal" ? { kind: "value", value: value.value } : { kind: "unknown" },
+    localExport: Boolean(local),
+    definition: expression
+  };
+}
+function resolvePlaySourceAuthoringContractEdition(marker, pinnedEdition) {
+  if (marker.kind === "unknown") {
+    throw new PlayAuthoringFieldValidationError(
+      "compatibility.authoringContract",
+      "play_authoring_binding_invalid",
+      'compatibility.authoringContract must be statically resolvable; declare "explicit-freshness" to opt into explicit freshness.'
+    );
+  }
+  if (marker.kind === "absent")
+    return _nullishCoalesce(pinnedEdition, () => ( PLAY_AUTHORING_CONTRACT_EDITION));
+  validatePlayAuthoringField("compatibility.authoringContract", marker.value);
+  if (pinnedEdition !== void 0 && pinnedEdition !== 10 && pinnedEdition !== PLAY_AUTHORING_CONTRACT_EDITION) {
+    throw new PlayAuthoringFieldValidationError(
+      "compatibility.authoringContract",
+      "play_authoring_binding_invalid",
+      `The source explicit-freshness contract requires authoringContractEdition ${PLAY_AUTHORING_CONTRACT_EDITION}; artifact-pinned edition 10 remains valid only for an already-published artifact.`
+    );
+  }
+  return pinnedEdition === 10 ? 10 : PLAY_AUTHORING_CONTRACT_EDITION;
+}
+
 // ../plays/bundling/index.ts
-var PLAY_BUNDLE_CACHE_NAMESPACE = "deepline-play-artifacts-docflow-jsdoc";
+var PLAY_BUNDLE_CACHE_NAMESPACE = "deepline-play-artifacts-docflow-jsdoc-pure-contracts";
 var PLAY_ARTIFACT_CACHE_DIR = _path.join.call(void 0, _os.tmpdir.call(void 0, ), PLAY_BUNDLE_CACHE_NAMESPACE);
 var PLAY_PROXY_NAMESPACE = "deepline-play-runtime-ref";
 var SOURCE_EXTENSIONS = [
@@ -1436,7 +3453,7 @@ function findSourceImportReferences(sourceCode) {
   );
 }
 function extractDefinedPlayName(sourceCode) {
-  return _nullishCoalesce(_optionalChain([extractDefinedPlayMetadata, 'call', _71 => _71(sourceCode, null), 'optionalAccess', _72 => _72.name]), () => ( null));
+  return _nullishCoalesce(_optionalChain([extractDefinedPlayMetadata, 'call', _86 => _86(sourceCode, null), 'optionalAccess', _87 => _87.name]), () => ( null));
 }
 function parsePlaySourceAst(sourceCode) {
   try {
@@ -1616,14 +3633,14 @@ function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Se
       false
     );
     const value = left !== null && right !== null ? `${left}${right}` : null;
-    if (!_optionalChain([value, 'optionalAccess', _73 => _73.trim, 'call', _74 => _74()])) return null;
+    if (!_optionalChain([value, 'optionalAccess', _88 => _88.trim, 'call', _89 => _89()])) return null;
     return trimResult ? value.trim() : value;
   }
-  const identifier = getIdentifierName3(expression);
-  if (!identifier || seen.has(identifier)) return null;
-  seen.add(identifier);
+  const identifier2 = getIdentifierName3(expression);
+  if (!identifier2 || seen.has(identifier2)) return null;
+  seen.add(identifier2);
   return staticStringFromExpression(
-    context.declarations.get(identifier),
+    context.declarations.get(identifier2),
     context,
     seen,
     trimResult
@@ -1647,11 +3664,11 @@ function objectExpressionFromNode(node, context, seen = /* @__PURE__ */ new Set(
   const expression = unwrapStaticExpression2(node);
   if (!expression) return null;
   if (expression.type === "ObjectExpression") return expression;
-  const identifier = getIdentifierName3(expression);
-  if (!identifier || seen.has(identifier)) return null;
-  seen.add(identifier);
+  const identifier2 = getIdentifierName3(expression);
+  if (!identifier2 || seen.has(identifier2)) return null;
+  seen.add(identifier2);
   return objectExpressionFromNode(
-    context.declarations.get(identifier),
+    context.declarations.get(identifier2),
     context,
     seen
   );
@@ -1719,27 +3736,42 @@ function staticNumberFromExpression(node, context, seen = /* @__PURE__ */ new Se
   if (expression.type === "Literal" && typeof expression.value === "number") {
     return expression.value;
   }
-  const identifier = getIdentifierName3(expression);
-  if (!identifier || seen.has(identifier)) return null;
-  seen.add(identifier);
+  const identifier2 = getIdentifierName3(expression);
+  if (!identifier2 || seen.has(identifier2)) return null;
+  seen.add(identifier2);
   return staticNumberFromExpression(
-    context.declarations.get(identifier),
+    context.declarations.get(identifier2),
     context,
     seen
   );
 }
-function toolErrorSchemaVersionFromOptions(node, context) {
-  const directCompatibility = resolveStaticProperty(
-    node,
-    "compatibility",
-    context
-  );
-  if (directCompatibility.kind === "unknown") return null;
+function compatibilityFromOptions(node, context) {
+  const direct = resolveStaticProperty(node, "compatibility", context);
+  if (direct.kind !== "found") {
+    if (direct.kind === "unknown") return direct;
+  } else {
+    let value = unwrapStaticExpression2(direct.value);
+    const seen = /* @__PURE__ */ new Set();
+    while (_optionalChain([value, 'optionalAccess', _90 => _90.type]) === "Identifier") {
+      const name = getIdentifierName3(value);
+      if (name === "undefined" && !context.declarations.has(name)) {
+        value = { type: "Literal", value: void 0 };
+        break;
+      }
+      if (seen.has(name)) return { kind: "unknown" };
+      seen.add(name);
+      value = unwrapStaticExpression2(context.declarations.get(name));
+    }
+    const nullish = _optionalChain([value, 'optionalAccess', _91 => _91.type]) === "Literal" && value.value == null;
+    const voidLiteral = _optionalChain([value, 'optionalAccess', _92 => _92.type]) === "UnaryExpression" && value.operator === "void" && isAstNode(value.argument) && value.argument.type === "Literal";
+    if (!nullish && !voidLiteral) return direct;
+  }
   const bindings = resolveStaticProperty(node, "bindings", context);
-  if (bindings.kind === "unknown") return null;
-  const bindingCompatibility = bindings.kind === "found" ? resolveStaticProperty(bindings.value, "compatibility", context) : { kind: "absent" };
-  if (bindingCompatibility.kind === "unknown") return null;
-  const compatibility = directCompatibility.kind === "found" ? directCompatibility : bindingCompatibility;
+  return bindings.kind === "found" ? resolveStaticProperty(bindings.value, "compatibility", context) : bindings;
+}
+function toolErrorSchemaVersionFromOptions(node, context) {
+  const compatibility = compatibilityFromOptions(node, context);
+  if (compatibility.kind === "unknown") return null;
   if (compatibility.kind === "absent") return void 0;
   const schema = resolveStaticProperty(
     compatibility.value,
@@ -1753,17 +3785,8 @@ function toolErrorSchemaVersionFromOptions(node, context) {
   return null;
 }
 function toolResponseReceiptRevisionFromOptions(node, context) {
-  const directCompatibility = resolveStaticProperty(
-    node,
-    "compatibility",
-    context
-  );
-  if (directCompatibility.kind === "unknown") return null;
-  const bindings = resolveStaticProperty(node, "bindings", context);
-  if (bindings.kind === "unknown") return null;
-  const bindingCompatibility = bindings.kind === "found" ? resolveStaticProperty(bindings.value, "compatibility", context) : { kind: "absent" };
-  if (bindingCompatibility.kind === "unknown") return null;
-  const compatibility = directCompatibility.kind === "found" ? directCompatibility : bindingCompatibility;
+  const compatibility = compatibilityFromOptions(node, context);
+  if (compatibility.kind === "unknown") return null;
   if (compatibility.kind === "absent") return void 0;
   const revision = resolveStaticProperty(
     compatibility.value,
@@ -2123,7 +4146,7 @@ function findDocflowContext(input) {
     if (!isAstNode(value)) continue;
     if (isDefinePlayCallExpression(value)) {
       const bounds = astNodeBounds(value);
-      if (bounds && bounds.start < lineEnd && bounds.end > lineStart && (!best || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _75 => _75(best), 'optionalAccess', _76 => _76.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _77 => _77(best), 'optionalAccess', _78 => _78.start]), () => ( 0))))) {
+      if (bounds && bounds.start < lineEnd && bounds.end > lineStart && (!best || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _93 => _93(best), 'optionalAccess', _94 => _94.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _95 => _95(best), 'optionalAccess', _96 => _96.start]), () => ( 0))))) {
         best = value;
       }
     }
@@ -2227,7 +4250,7 @@ function instrumentPlayDocflowRuntimeHits(sourceCode) {
     }
     const lineStart = lineStarts[binding.line - 1];
     if (lineStart !== void 0) {
-      const indentationLength = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _79 => _79.exec, 'call', _80 => _80(sourceCode.slice(lineStart)), 'optionalAccess', _81 => _81[0], 'access', _82 => _82.length]), () => ( 0));
+      const indentationLength = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _97 => _97.exec, 'call', _98 => _98(sourceCode.slice(lineStart)), 'optionalAccess', _99 => _99[0], 'access', _100 => _100.length]), () => ( 0));
       replacements.push({
         start: lineStart + indentationLength,
         end: lineStart + indentationLength,
@@ -2559,20 +4582,35 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
       })).sort((left, right) => left.filePath.localeCompare(right.filePath))
     })
   );
-  const metadata = _nullishCoalesce(extractDefinedPlayMetadata(sourceCode, exportName), () => ( (exportName === "default" ? extractDefinedPlayMetadata(sourceCode, null) : null)));
-  if (_optionalChain([metadata, 'optionalAccess', _83 => _83.toolErrorSchemaVersionUnknown])) {
+  const sourceAst = parsePlaySourceAst(sourceCode);
+  if (!sourceAst)
     throw new Error(
-      "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1."
-    );
-  }
-  if (_optionalChain([metadata, 'optionalAccess', _84 => _84.toolResponseReceiptRevisionUnknown])) {
-    throw new Error(
-      "definePlay compatibility.toolResponseReceiptRevision must be a static non-empty string."
+      "Play source syntax must be valid before selecting its authoring edition."
     );
+  const selection = extractPlaySourceAuthoringEdition(
+    sourceAst,
+    exportName === "default" ? null : exportName
+  );
+  const metadata = _nullishCoalesce((selection.marker.kind === "value" && selection.definition ? playMetadataFromDefinePlayCall(
+    selection.definition,
+    buildPlayMetadataContext(sourceAst)
+  ) : extractDefinedPlayMetadata(sourceCode, exportName)), () => ( (exportName === "default" ? extractDefinedPlayMetadata(sourceCode, null) : null)));
+  const compatibilityDiagnostic = _optionalChain([metadata, 'optionalAccess', _101 => _101.toolErrorSchemaVersionUnknown]) ? "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1." : _optionalChain([metadata, 'optionalAccess', _102 => _102.toolResponseReceiptRevisionUnknown]) ? "definePlay compatibility.toolResponseReceiptRevision must be a static non-empty string." : null;
+  try {
+    resolvePlaySourceAuthoringContractEdition(selection.marker);
+  } catch (error) {
+    if (compatibilityDiagnostic && selection.marker.kind === "unknown") {
+      throw new Error(
+        `${compatibilityDiagnostic}
+${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    throw error;
   }
-  const playName = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _85 => _85.name]), () => ( null));
-  const playDescription = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _86 => _86.description]), () => ( null));
-  const sandboxRuntimeDeclaration = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _87 => _87.sandboxRuntimeDeclaration]), () => ( null));
+  if (compatibilityDiagnostic) throw new Error(compatibilityDiagnostic);
+  const playName = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _103 => _103.name]), () => ( null));
+  const playDescription = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _104 => _104.description]), () => ( null));
+  const sandboxRuntimeDeclaration = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _105 => _105.sandboxRuntimeDeclaration]), () => ( null));
   return {
     sourceCode,
     sourceFiles: Object.fromEntries(
@@ -2590,8 +4628,10 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
     playName,
     playDescription,
     sandboxRuntimeDeclaration,
-    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _88 => _88.toolErrorSchemaVersion]), () => ( null)),
-    toolResponseReceiptRevision: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _89 => _89.toolResponseReceiptRevision]), () => ( null)),
+    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _106 => _106.toolErrorSchemaVersion]), () => ( null)),
+    toolResponseReceiptRevision: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _107 => _107.toolResponseReceiptRevision]), () => ( null)),
+    sourceAuthoringEdition: selection.marker,
+    sourceHasLocalPlayExport: selection.localExport,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath)
     )
@@ -2633,7 +4673,7 @@ async function writeArtifactCache(artifact, adapter) {
     /* turbopackIgnore: true */
     artifactCachePath(
       artifact.graphHash,
-      _nullishCoalesce(artifact.artifactKind, () => ( _chunkS6R3OX7Bjs.PLAY_ARTIFACT_KINDS.cjsNode20)),
+      _nullishCoalesce(artifact.artifactKind, () => ( _chunkE4CABWXLjs.PLAY_ARTIFACT_KINDS.cjsNode20)),
       adapter
     ),
     JSON.stringify(artifact),
@@ -2705,9 +4745,9 @@ async function runEsbuildForCjsNode(entryFile, customerSourceFilePaths, imported
       (plugin) => plugin != null
     )
   });
-  const codeFile = _optionalChain([result, 'access', _90 => _90.outputFiles, 'optionalAccess', _91 => _91.find, 'call', _92 => _92((f) => f.path.endsWith(".cjs"))]);
-  const mapFile = _optionalChain([result, 'access', _93 => _93.outputFiles, 'optionalAccess', _94 => _94.find, 'call', _95 => _95((f) => f.path.endsWith(".cjs.map"))]);
-  if (!_optionalChain([codeFile, 'optionalAccess', _96 => _96.text]) || !_optionalChain([mapFile, 'optionalAccess', _97 => _97.text])) {
+  const codeFile = _optionalChain([result, 'access', _108 => _108.outputFiles, 'optionalAccess', _109 => _109.find, 'call', _110 => _110((f) => f.path.endsWith(".cjs"))]);
+  const mapFile = _optionalChain([result, 'access', _111 => _111.outputFiles, 'optionalAccess', _112 => _112.find, 'call', _113 => _113((f) => f.path.endsWith(".cjs.map"))]);
+  if (!_optionalChain([codeFile, 'optionalAccess', _114 => _114.text]) || !_optionalChain([mapFile, 'optionalAccess', _115 => _115.text])) {
     return ["Play bundling produced incomplete output."];
   }
   return {
@@ -2718,22 +4758,39 @@ async function runEsbuildForCjsNode(entryFile, customerSourceFilePaths, imported
 }
 async function bundlePlayFile(filePath, options) {
   const adapter = options.adapter;
-  const target = _nullishCoalesce(options.target, () => ( _chunkS6R3OX7Bjs.PLAY_ARTIFACT_KINDS.cjsNode20));
-  const exportName = _optionalChain([options, 'access', _98 => _98.exportName, 'optionalAccess', _99 => _99.trim, 'call', _100 => _100()]) || "default";
+  const target = _nullishCoalesce(options.target, () => ( _chunkE4CABWXLjs.PLAY_ARTIFACT_KINDS.cjsNode20));
+  const exportName = _optionalChain([options, 'access', _116 => _116.exportName, 'optionalAccess', _117 => _117.trim, 'call', _118 => _118()]) || "default";
   assertValidExportName(exportName);
   const absolutePath = await normalizeLocalPath(filePath);
   const sourceIdentityRoot = adapter.sourceIdentityRoot;
-  _optionalChain([adapter, 'access', _101 => _101.warnAboutNonDevelopmentBundling, 'optionalCall', _102 => _102(absolutePath)]);
+  _optionalChain([adapter, 'access', _119 => _119.warnAboutNonDevelopmentBundling, 'optionalCall', _120 => _120(absolutePath)]);
   try {
+    const preservedCompatibility = options.compatibility === void 0 ? void 0 : {
+      ...options.compatibility,
+      authoringContractEdition: normalizePlayContractCompatibility(
+        options.compatibility
+      ).authoringContractEdition
+    };
     const analysis = await analyzeSourceGraph(
       absolutePath,
       adapter,
       exportName
     );
+    const edition = resolvePlaySourceAuthoringContractEdition(
+      analysis.sourceAuthoringEdition,
+      _optionalChain([preservedCompatibility, 'optionalAccess', _121 => _121.authoringContractEdition])
+    );
+    const markedSource = analysis.sourceAuthoringEdition.kind === "value";
+    if (markedSource && !analysis.sourceHasLocalPlayExport) {
+      throw new Error(
+        "Edition 10 source must select a local ESM definePlay export."
+      );
+    }
     analysis.graphHash = sha256(
       `${analysis.graphHash}
 entry-export:${exportName}
-authoring-contract-edition:${_chunkZ4VNJOF7js.PLAY_AUTHORING_CONTRACT_EDITION}`
+authoring-contract-edition:${edition}${edition >= 10 ? "\nimported-proxy-options:description" : ""}${preservedCompatibility === void 0 ? "\ndataset-row-input:current_run" : `
+preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
     );
     const sourceFiles = Object.fromEntries(
       Object.entries(analysis.sourceFiles).map(([sourcePath, sourceCode]) => [
@@ -2758,7 +4815,7 @@ authoring-contract-edition:${_chunkZ4VNJOF7js.PLAY_AUTHORING_CONTRACT_EDITION}`
       };
     }
     const typecheckErrors = [
-      ...await _asyncNullishCoalesce(await _optionalChain([adapter, 'access', _103 => _103.typecheckPlaySource, 'optionalCall', _104 => _104({
+      ...await _asyncNullishCoalesce(await _optionalChain([adapter, 'access', _122 => _122.typecheckPlaySource, 'optionalCall', _123 => _123({
         sourceCode: analysis.sourceCode,
         sourcePath: absolutePath,
         importedFilePaths: [
@@ -2799,13 +4856,16 @@ authoring-contract-edition:${_chunkZ4VNJOF7js.PLAY_AUTHORING_CONTRACT_EDITION}`
         success: true,
         artifact: {
           ...cachedArtifact,
+          ...markedSource ? { exportName } : {},
           entryFile,
           sourceHash: analysis.sourceHash,
           importPolicy,
-          compatibility: buildPlayContractCompatibility({
+          compatibility: _nullishCoalesce(preservedCompatibility, () => ( buildPlayContractCompatibility({
+            authoringContractEdition: edition,
+            datasetRowInput: "current_run",
             toolErrorSchemaVersion: _nullishCoalesce(analysis.toolErrorSchemaVersion, () => ( void 0)),
             toolResponseReceiptRevision: _nullishCoalesce(analysis.toolResponseReceiptRevision, () => ( void 0))
-          }),
+          }))),
           cacheHit: true
         },
         sourceCode: analysis.sourceCode,
@@ -2858,6 +4918,7 @@ authoring-contract-edition:${_chunkZ4VNJOF7js.PLAY_AUTHORING_CONTRACT_EDITION}`
       };
     }
     const artifact = {
+      ...markedSource ? { exportName } : {},
       codeFormat: "cjs_module",
       artifactKind: target,
       entryFile,
@@ -2869,10 +4930,12 @@ authoring-contract-edition:${_chunkZ4VNJOF7js.PLAY_AUTHORING_CONTRACT_EDITION}`
       bundledCode: executableCode,
       sourceMap: normalizedSourceMap,
       importPolicy,
-      compatibility: buildPlayContractCompatibility({
+      compatibility: _nullishCoalesce(preservedCompatibility, () => ( buildPlayContractCompatibility({
+        authoringContractEdition: edition,
+        datasetRowInput: "current_run",
         toolErrorSchemaVersion: _nullishCoalesce(analysis.toolErrorSchemaVersion, () => ( void 0)),
         toolResponseReceiptRevision: _nullishCoalesce(analysis.toolResponseReceiptRevision, () => ( void 0))
-      }),
+      }))),
       generatedAt: Date.now(),
       cacheHit: false
     };
@@ -2943,8 +5006,8 @@ var PLAY_RUNTIME_PROVIDERS = {
     // Server runs execute on Daytona; the local-dev/test shape swaps the runner
     // axis to local_process (same as the local profile) via an explicit
     // runtimeBackend override at submit while tests drive local_process.
-    runner: _chunkS6R3OX7Bjs.PLAY_RUNTIME_BACKENDS.daytona,
-    artifactKind: _chunkS6R3OX7Bjs.PLAY_ARTIFACT_KINDS.cjsNode20,
+    runner: _chunkE4CABWXLjs.PLAY_RUNTIME_BACKENDS.daytona,
+    artifactKind: _chunkE4CABWXLjs.PLAY_ARTIFACT_KINDS.cjsNode20,
     label: "Absurd (Postgres-native durable) scheduler + one-shot Daytona runner"
   }
 };
@@ -2952,7 +5015,7 @@ function defaultPlayRuntimeProvider() {
   return PLAY_RUNTIME_PROVIDERS.absurd;
 }
 function resolvePlayRuntimeProvider(override) {
-  if (_optionalChain([override, 'optionalAccess', _105 => _105.trim, 'call', _106 => _106()])) {
+  if (_optionalChain([override, 'optionalAccess', _124 => _124.trim, 'call', _125 => _125()])) {
     const id = override.trim();
     if (id in PLAY_RUNTIME_PROVIDERS) {
       return PLAY_RUNTIME_PROVIDERS[id];
@@ -2978,7 +5041,7 @@ function resolveExecutionProfile(override) {
   try {
     return resolvePlayRuntimeProvider(override);
   } catch (error) {
-    if (_optionalChain([override, 'optionalAccess', _107 => _107.trim, 'call', _108 => _108()])) {
+    if (_optionalChain([override, 'optionalAccess', _126 => _126.trim, 'call', _127 => _127()])) {
       throw new Error(
         `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
           PLAY_EXECUTION_PROFILES
@@ -2992,7 +5055,7 @@ function resolveEnabledExecutionProfile(override) {
   try {
     return resolveEnabledPlayRuntimeProvider(override);
   } catch (error) {
-    if (_optionalChain([override, 'optionalAccess', _109 => _109.trim, 'call', _110 => _110()]) && error instanceof Error && /Unsupported play runtime provider/.test(error.message)) {
+    if (_optionalChain([override, 'optionalAccess', _128 => _128.trim, 'call', _129 => _129()]) && error instanceof Error && /Unsupported play runtime provider/.test(error.message)) {
       throw new Error(
         `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
           PLAY_EXECUTION_PROFILES
@@ -3219,7 +5282,7 @@ function localImportSpecifiers(sourceCode) {
   for (const match of source.matchAll(
     /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]/g
   )) {
-    if (_optionalChain([match, 'access', _111 => _111[1], 'optionalAccess', _112 => _112.startsWith, 'call', _113 => _113(".")])) specifiers.push(match[1]);
+    if (_optionalChain([match, 'access', _130 => _130[1], 'optionalAccess', _131 => _131.startsWith, 'call', _132 => _132(".")])) specifiers.push(match[1]);
   }
   for (const match of source.matchAll(
     /\brequire\s*\(\s*(['"])(\.[^'"]*)\1\s*\)/g
@@ -3400,7 +5463,10 @@ function createSdkPlayBundlingAdapter() {
   return {
     projectRoot: PROJECT_ROOT,
     nodeModulesDir: HAS_PACKAGED_BUNDLING_SOURCES ? _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "node_modules") : _path.resolve.call(void 0, PROJECT_ROOT, "node_modules"),
-    cacheDir: _path.join.call(void 0, _os.tmpdir.call(void 0, ), PLAY_BUNDLE_CACHE_NAMESPACE),
+    // Emit the current SDK/compiler implementation on every invocation. The
+    // customer graph hash does not include SDK/compiler source bytes, so reusing an
+    // artifact can silently retain an older compiler or SDK implementation.
+    cacheDir: null,
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
@@ -3417,6 +5483,7 @@ async function bundlePlayFile2(filePath, options = {}) {
   const result = await bundlePlayFile(filePath, {
     target: _nullishCoalesce(options.target, () => ( defaultPlayBundleTarget())),
     exportName: options.exportName,
+    compatibility: options.compatibility,
     adapter: {
       ...createSdkPlayBundlingAdapter(),
       sourceIdentityRoot,
@@ -3429,7 +5496,7 @@ async function bundlePlayFile2(filePath, options = {}) {
 }
 async function bundleDeployPlayFile(entryFile, options) {
   return bundlePlayFile(entryFile, {
-    target: _chunkS6R3OX7Bjs.PLAY_ARTIFACT_KINDS.cjsNode20,
+    target: _chunkE4CABWXLjs.PLAY_ARTIFACT_KINDS.cjsNode20,
     adapter: {
       ...createSdkPlayBundlingAdapter(),
       sourceIdentityRoot: options.sourceIdentityRoot,