deepline 0.3.409 → 0.3.411

package/dist/cli/{chunk-6BJK4EJ3.mjs → chunk-AARWVK4C.mjs}

@@ -2,25 +2,25 @@ import {
   validatePlaySourceFilesHaveNoInlineSecrets
 } from "./chunk-H7HIDGZ7.mjs";
 import {
-  PLAY_AUTHORING_CONTRACT_EDITION
-} from "./chunk-CLJGSOVM.mjs";
-import {
+  InvalidToolResponseReceiptRevisionError,
   PLAY_ARTIFACT_KINDS,
   PLAY_RUNTIME_BACKENDS,
   RAW_V2_TOOL_RESPONSE_CONTRACT,
   RAW_V2_TOOL_RESPONSE_RECEIPT_REVISION,
+  UnsupportedToolResponseContractError,
+  normalizeToolResponseContract,
   normalizeToolResponseReceiptRevision
-} from "./chunk-6IKARAYD.mjs";
+} from "./chunk-L2VKAASU.mjs";
 import {
+  SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS,
   TOOL_EXECUTION_ERROR_SCHEMA_VERSION
-} from "./chunk-NXGCO4JB.mjs";
+} from "./chunk-E4IXDAZI.mjs";
 import {
   CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION
 } from "./chunk-WZYKRD7T.mjs";
 
 // src/plays/bundle-play-file.ts
-import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync2 } from "fs";
 import { realpath as realpath2 } from "fs/promises";
@@ -47,11 +47,1816 @@ import {
   transformSync
 } from "esbuild";
 
+// ../plays/authoring-contract.ts
+import { Type } from "@sinclair/typebox";
+import { Value } from "@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 = Type.String({
+  pattern: "^[A-Z][A-Z0-9_]{1,63}$",
+  description: "An uppercase environment variable name beginning with a letter."
+});
+var SqlListenerFilterScalarSchema = Type.Union([
+  Type.String(),
+  Type.Number(),
+  Type.Boolean(),
+  Type.Null()
+]);
+var PLAY_AUTHORING_FIELD_REGISTRY = {
+  displayName: {
+    schema: 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: 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: Type.Union([Type.Literal(0), 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: 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: 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: 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: 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: 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: 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: 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: 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: Type.Union([Type.Literal("standard"), 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: 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: 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: 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: 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: Type.Array(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: 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: 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: 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: Type.Union([
+      Type.Literal("INSERT"),
+      Type.Literal("UPDATE"),
+      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: Type.Record(Type.String(), 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: Type.Record(Type.String(), 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: 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: 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: 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: 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: 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: Type.Union([Type.Null(), 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: 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: 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: Type.Record(Type.String(), 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: 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: 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: 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: 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: 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: Type.Record(
+      Type.String(),
+      Type.Union([
+        Type.String({ minLength: 1 }),
+        Type.Array(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: Type.Record(
+      Type.String(),
+      Type.Union([
+        Type.String({ minLength: 1 }),
+        Type.Array(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: Type.Array(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: 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: 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: Type.Union([
+      Type.String({ minLength: 1 }),
+      Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+      Type.Function(
+        [Type.Record(Type.String(), Type.Unknown()), Type.Integer()],
+        Type.Union([
+          Type.String(),
+          Type.Number(),
+          Type.Readonly(Type.Array(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: Type.Union([Type.Literal("source_row"), 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: Type.Union([Type.Literal("isolate"), 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: Type.Union([Type.Literal("upsert"), 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: Type.Array(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: 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: 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: Type.Union([Type.Null(), 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: 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: Type.Union([Type.Null(), 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: 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: Type.Union([
+      Type.String({ minLength: 1 }),
+      Type.Union([
+        Type.Object(
+          { playName: Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        ),
+        Type.Object(
+          { name: 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: Type.Record(Type.String(), 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: 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: 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: 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: 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: Type.Union([
+      Type.String({ minLength: 1 }),
+      Type.Union([
+        Type.Object(
+          { playName: Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        ),
+        Type.Object(
+          { name: 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: Type.Record(Type.String(), 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: 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: 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: 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: Type.Union([
+      Type.String({ minLength: 1 }),
+      Type.Object(
+        {
+          kind: Type.Optional(Type.Literal("sql.query")),
+          text: Type.String({ minLength: 1 }),
+          values: Type.Optional(Type.Array(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: 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: 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: 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: 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: 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: 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: Type.Record(Type.String(), 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: 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: 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: Type.Union([Type.Null(), 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: 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: 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: 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: 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 = 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.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 = CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION;
+var UnsupportedPlayToolErrorSchemaVersionError = class extends Error {
+  constructor(value) {
+    super(
+      `Unsupported Play tool error schema version ${String(value)}. Supported versions: ${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 = compatibility.toolErrorSchemaVersion ?? 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 (!SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS.includes(
+    requestedToolErrorSchemaVersion
+  )) {
+    throw new UnsupportedPlayToolErrorSchemaVersionError(
+      requestedToolErrorSchemaVersion
+    );
+  }
+  let toolResponseContract;
+  let toolResponseReceiptRevision;
+  try {
+    toolResponseContract = normalizeToolResponseContract(
+      compatibility.toolResponseContract
+    );
+    toolResponseReceiptRevision = normalizeToolResponseReceiptRevision(
+      compatibility.toolResponseReceiptRevision
+    );
+  } catch (error) {
+    if (error instanceof UnsupportedToolResponseContractError || error instanceof InvalidToolResponseReceiptRevisionError) {
+      throw new InvalidPlayContractCompatibilityError(error.message);
+    }
+    throw error;
+  }
+  return {
+    ...compatibility,
+    toolErrorSchemaVersion: TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+    toolResponseContract,
+    ...toolResponseReceiptRevision ? { toolResponseReceiptRevision } : {},
+    authoringContractEdition: normalizePlayAuthoringContractEdition(
+      compatibility.authoringContractEdition
+    )
+  };
+}
 function buildPlayContractCompatibility(input) {
   return {
     artifactVersion: PLAY_ARTIFACT_VERSION,
+    ...input?.datasetRowInput ? { datasetRowInput: input.datasetRowInput } : {},
     runtimeBackend: input?.runtimeBackend ?? null,
     toolErrorSchemaVersion: input?.toolErrorSchemaVersion ?? TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
     authoringContractEdition: input?.authoringContractEdition ?? PLAY_AUTHORING_CONTRACT_EDITION,
@@ -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 + (identifier.index ?? 0);
+    const identifier2 = /[A-Za-z][\w-]*/.exec(fragment.slice(cursor));
+    if (!identifier2) break;
+    const start = cursor + (identifier2.index ?? 0);
     const parsed = parseMermaidNodeAtStart(fragment.slice(start));
     if (parsed?.shaped || parsed?.unterminated) nodes.push(parsed);
-    cursor = start + Math.max(parsed?.length ?? identifier[0].length, 1);
+    cursor = start + Math.max(parsed?.length ?? identifier2[0].length, 1);
   }
   return nodes;
 }
@@ -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 = 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 = match.index ?? 0;
     const previous = expression[index - 1] ?? "";
-    const next = expression[index + identifier.length] ?? "";
-    if (JS_WORDS.has(identifier) || identifier === output || previous === "." || next === ":" || /^\s*\(/.test(expression.slice(index + identifier.length))) {
+    const next = 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],
@@ -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(
+          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 = 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 (left?.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 (value2?.type === "UnaryExpression" && value2.operator === "void") {
+      const operand = unwrap(isAstNode(value2.argument) ? value2.argument : null);
+      if (operand?.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(declarations.get(name) ?? null, new Set(seen).add(name));
+  };
+  const staticKey = (node) => {
+    const value2 = resolve4(node);
+    if (value2?.type === "Literal" && (typeof value2.value === "string" || typeof value2.value === "number")) {
+      return String(value2.value);
+    }
+    if (value2?.type === "TemplateLiteral" && astArray(value2.expressions).length === 0) {
+      const quasi = astArray(value2.quasis)[0];
+      const cooked = quasi?.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 (object?.type === "Literal" && object.value == null)
+      return { kind: "absent" };
+    if (object?.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) : 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(args[0] ?? null);
+    const objectForm = first?.type === "ObjectExpression" || args.length === 1;
+    const options = objectForm ? args[0] ?? null : args[2] ?? null;
+    const direct = property(options, "compatibility");
+    let compatibility = direct;
+    if (direct.kind === "absent" || direct.kind === "found" && resolve4(direct.value)?.type === "Literal" && resolve4(direct.value)?.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(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 = exportName ?? "default";
+  const local = exports.get(requested);
+  const expression = resolve4(
+    local ?? legacyExports.get(requested) ?? (exportName === null ? 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: value?.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 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 = join(tmpdir(), PLAY_BUNDLE_CACHE_NAMESPACE);
 var PLAY_PROXY_NAMESPACE = "deepline-play-runtime-ref";
 var SOURCE_EXTENSIONS = [
@@ -1619,11 +3636,11 @@ function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Se
     if (!value?.trim()) 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 (value?.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 = value?.type === "Literal" && value.value == null;
+    const voidLiteral = value?.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,
@@ -2559,17 +4582,32 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
       })).sort((left, right) => left.filePath.localeCompare(right.filePath))
     })
   );
-  const metadata = extractDefinedPlayMetadata(sourceCode, exportName) ?? (exportName === "default" ? extractDefinedPlayMetadata(sourceCode, null) : null);
-  if (metadata?.toolErrorSchemaVersionUnknown) {
+  const sourceAst = parsePlaySourceAst(sourceCode);
+  if (!sourceAst)
     throw new Error(
-      "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1."
-    );
-  }
-  if (metadata?.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 = (selection.marker.kind === "value" && selection.definition ? playMetadataFromDefinePlayCall(
+    selection.definition,
+    buildPlayMetadataContext(sourceAst)
+  ) : extractDefinedPlayMetadata(sourceCode, exportName)) ?? (exportName === "default" ? extractDefinedPlayMetadata(sourceCode, null) : null);
+  const compatibilityDiagnostic = metadata?.toolErrorSchemaVersionUnknown ? "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1." : metadata?.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;
   }
+  if (compatibilityDiagnostic) throw new Error(compatibilityDiagnostic);
   const playName = metadata?.name ?? null;
   const playDescription = metadata?.description ?? null;
   const sandboxRuntimeDeclaration = metadata?.sandboxRuntimeDeclaration ?? null;
@@ -2592,6 +4630,8 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
     sandboxRuntimeDeclaration,
     toolErrorSchemaVersion: metadata?.toolErrorSchemaVersion ?? null,
     toolResponseReceiptRevision: metadata?.toolResponseReceiptRevision ?? null,
+    sourceAuthoringEdition: selection.marker,
+    sourceHasLocalPlayExport: selection.localExport,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath)
     )
@@ -2725,15 +4765,32 @@ async function bundlePlayFile(filePath, options) {
   const sourceIdentityRoot = adapter.sourceIdentityRoot;
   adapter.warnAboutNonDevelopmentBundling?.(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,
+      preservedCompatibility?.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:${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]) => [
@@ -2799,10 +4856,13 @@ authoring-contract-edition:${PLAY_AUTHORING_CONTRACT_EDITION}`
         success: true,
         artifact: {
           ...cachedArtifact,
+          ...markedSource ? { exportName } : {},
           entryFile,
           sourceHash: analysis.sourceHash,
           importPolicy,
-          compatibility: buildPlayContractCompatibility({
+          compatibility: preservedCompatibility ?? buildPlayContractCompatibility({
+            authoringContractEdition: edition,
+            datasetRowInput: "current_run",
             toolErrorSchemaVersion: analysis.toolErrorSchemaVersion ?? void 0,
             toolResponseReceiptRevision: analysis.toolResponseReceiptRevision ?? void 0
           }),
@@ -2858,6 +4918,7 @@ authoring-contract-edition:${PLAY_AUTHORING_CONTRACT_EDITION}`
       };
     }
     const artifact = {
+      ...markedSource ? { exportName } : {},
       codeFormat: "cjs_module",
       artifactKind: target,
       entryFile,
@@ -2869,7 +4930,9 @@ authoring-contract-edition:${PLAY_AUTHORING_CONTRACT_EDITION}`
       bundledCode: executableCode,
       sourceMap: normalizedSourceMap,
       importPolicy,
-      compatibility: buildPlayContractCompatibility({
+      compatibility: preservedCompatibility ?? buildPlayContractCompatibility({
+        authoringContractEdition: edition,
+        datasetRowInput: "current_run",
         toolErrorSchemaVersion: analysis.toolErrorSchemaVersion ?? void 0,
         toolResponseReceiptRevision: analysis.toolResponseReceiptRevision ?? void 0
       }),
@@ -3400,7 +5463,10 @@ function createSdkPlayBundlingAdapter() {
   return {
     projectRoot: PROJECT_ROOT,
     nodeModulesDir: HAS_PACKAGED_BUNDLING_SOURCES ? resolve3(SDK_PACKAGE_ROOT, "node_modules") : resolve3(PROJECT_ROOT, "node_modules"),
-    cacheDir: join3(tmpdir2(), 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: options.target ?? defaultPlayBundleTarget(),
     exportName: options.exportName,
+    compatibility: options.compatibility,
     adapter: {
       ...createSdkPlayBundlingAdapter(),
       sourceIdentityRoot,