deepline 0.3.49 → 0.3.51

package/dist/index.js

@@ -32,6 +32,7 @@ var src_exports = {};
 __export(src_exports, {
   AuthError: () => AuthError,
   ConfigError: () => ConfigError,
+  CtxFetchHttpError: () => CtxFetchHttpError,
   DEEPLINE_EXTRACTOR_TARGETS: () => DEEPLINE_EXTRACTOR_TARGETS,
   DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS: () => DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS,
   DEEPLINE_TOOL_CATEGORIES: () => DEEPLINE_TOOL_CATEGORIES,
@@ -815,7 +816,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.49",
+  version: "0.3.51",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1
@@ -6806,122 +6807,6 @@ var DeeplineClient = class {
   }
 };
 
-// src/monitors.ts
-function defineMonitor(definition) {
-  if (!definition || typeof definition !== "object") {
-    throw new Error("defineMonitor(definition) requires a definition object.");
-  }
-  const key = typeof definition.key === "string" ? definition.key.trim() : "";
-  if (!key) {
-    throw new Error('defineMonitor(definition) requires a non-empty "key".');
-  }
-  const tool = typeof definition.tool === "string" ? definition.tool.trim() : "";
-  if (!tool) {
-    throw new Error(
-      'defineMonitor(definition) requires a non-empty monitor tool id in "tool" (e.g. "deepline_native.company_radar").'
-    );
-  }
-  if (!definition.payload || typeof definition.payload !== "object" || Array.isArray(definition.payload)) {
-    throw new Error(
-      'defineMonitor(definition) requires "payload" to be a JSON object.'
-    );
-  }
-  if (definition.name !== void 0 && typeof definition.name !== "string") {
-    throw new Error('defineMonitor(definition) "name" must be a string.');
-  }
-  if (definition.controls !== void 0 && (typeof definition.controls !== "object" || Array.isArray(definition.controls))) {
-    throw new Error(
-      'defineMonitor(definition) "controls" must be a JSON object.'
-    );
-  }
-  return definition;
-}
-
-// ../plays/bootstrap-routes.ts
-var DEEPLINE_TOOL_CATEGORIES = [
-  "company_search",
-  "people_search",
-  "people_enrich",
-  "email_finder",
-  "email_verify",
-  "phone_finder",
-  "phone_verify",
-  "identity_resolution",
-  "reverse_lookup",
-  "enrichment",
-  "batch",
-  "premium",
-  "free"
-];
-var PLAY_BOOTSTRAP_TEMPLATES = [
-  "people-list",
-  "company-list",
-  "people-email",
-  "people-phone",
-  "company-people",
-  "company-people-email",
-  "company-people-phone"
-];
-var PLAY_BOOTSTRAP_SOURCE_KINDS = [
-  "csv",
-  "play",
-  "provider",
-  "providers"
-];
-var PLAY_BOOTSTRAP_STAGE_KINDS = [
-  "play",
-  "provider",
-  "providers"
-];
-var PLAY_BOOTSTRAP_FINDER_KINDS = [
-  "email_finder",
-  "phone_finder"
-];
-var PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY = "company_search";
-var PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY = "people_search";
-var PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER = {
-  email_finder: "email_finder",
-  phone_finder: "phone_finder"
-};
-var PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER = {
-  email_finder: "email",
-  phone_finder: "phone"
-};
-var PLAY_BOOTSTRAP_CONTACT_FIELDS = [
-  "first_name",
-  "last_name",
-  "domain",
-  "company_name",
-  "linkedin_url",
-  "title",
-  "email",
-  "phone"
-];
-var PLAY_BOOTSTRAP_COMPANY_FIELDS = [
-  "domain",
-  "company_domain",
-  "company_name",
-  "linkedin_url",
-  "website"
-];
-function isPlayBootstrapFinderKind(value) {
-  return PLAY_BOOTSTRAP_FINDER_KINDS.includes(value);
-}
-function isPlayBootstrapTemplate(value) {
-  return PLAY_BOOTSTRAP_TEMPLATES.includes(value);
-}
-function formatPlayBootstrapFinderKinds() {
-  return PLAY_BOOTSTRAP_FINDER_KINDS.join("|");
-}
-function formatPlayBootstrapTemplates() {
-  return PLAY_BOOTSTRAP_TEMPLATES.join("|");
-}
-function formatPlayBootstrapFinderKindsForSentence() {
-  const allButLast = PLAY_BOOTSTRAP_FINDER_KINDS.slice(0, -1);
-  const last = PLAY_BOOTSTRAP_FINDER_KINDS.at(-1);
-  return `${allButLast.join(", ")} or ${last}`;
-}
-
 // ../plays/email-status.ts
 function normalizeKey(value) {
   if (value == null) return null;
@@ -8378,6 +8263,1402 @@ function replaceAtPath(root, path, replacement) {
   return replace(root, 0);
 }
 
+// ../plays/authoring-contract.ts
+var import_typebox = require("@sinclair/typebox");
+var import_value = require("@sinclair/typebox/value");
+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 CtxFetchHttpError = class extends Error {
+  /** Build the error from the durable response record. */
+  constructor(response) {
+    const body = response.bodyText || "empty response body";
+    super(
+      `ctx.fetch(${response.url}) returned HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}: ${body}`
+    );
+    this.response = response;
+    this.name = "CtxFetchHttpError";
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.url = response.url;
+    this.headers = response.headers;
+    this.bodyText = response.bodyText;
+    this.json = response.json;
+  }
+  /**
+   * Play source and the runtime are separately bundled. Recognize the stable
+   * public error code so `instanceof` works across that boundary as well.
+   */
+  static [Symbol.hasInstance](value) {
+    return value !== null && typeof value === "object" && value.code === "CTX_FETCH_HTTP_ERROR";
+  }
+  /** Stable machine-readable HTTP-failure code. */
+  code = "CTX_FETCH_HTTP_ERROR";
+  /** Upstream HTTP status. */
+  status;
+  /** Upstream HTTP status text. */
+  statusText;
+  /** Final response URL after redirects. */
+  url;
+  /** Secret-redacted response headers. */
+  headers;
+  /** Complete secret-redacted response body. */
+  bodyText;
+  /** Eagerly parsed secret-redacted JSON, or null. */
+  json;
+};
+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 = import_typebox.Type.String({
+  pattern: "^[A-Z][A-Z0-9_]{1,63}$",
+  description: "An uppercase environment variable name beginning with a letter."
+});
+var SqlListenerFilterScalarSchema = import_typebox.Type.Union([
+  import_typebox.Type.String(),
+  import_typebox.Type.Number(),
+  import_typebox.Type.Boolean(),
+  import_typebox.Type.Null()
+]);
+var PLAY_AUTHORING_FIELD_REGISTRY = {
+  description: {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich a company.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Legacy play."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Optional non-empty human-readable summary of the Play.",
+    errorMessage: "description must be a non-empty static string."
+  },
+  "compatibility.toolErrorSchemaVersion": {
+    schema: import_typebox.Type.Union([import_typebox.Type.Literal(0), import_typebox.Type.Literal(1)]),
+    fixtures: {
+      valid: 1,
+      invalid: 2,
+      absent: void 0,
+      unresolved: { expression: "version" },
+      edition1: 0
+    },
+    referenceType: "0 | 1",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Artifact-pinned tool error behavior, either 0 or 1.",
+    errorMessage: "compatibility.toolErrorSchemaVersion must be the static literal 0 or 1."
+  },
+  "compatibility.toolResponseReceiptRevision": {
+    schema: import_typebox.Type.String({
+      minLength: 1,
+      maxLength: 64,
+      pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$"
+    }),
+    fixtures: {
+      valid: "raw-v2-receipt-v1",
+      invalid: "has spaces",
+      absent: void 0,
+      unresolved: { expression: "revision" },
+      edition1: void 0
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Explicit durable-receipt revision for a response transformation; bump only when serialized tool output changes.",
+    errorMessage: "compatibility.toolResponseReceiptRevision must be a non-empty static identifier using letters, numbers, dots, underscores, or hyphens."
+  },
+  inline: {
+    schema: import_typebox.Type.Boolean(),
+    fixtures: {
+      valid: true,
+      invalid: "true",
+      absent: void 0,
+      unresolved: { expression: "inline" },
+      edition1: false
+    },
+    referenceType: "boolean",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Compiler hint for an inline named Play handler.",
+    errorMessage: "inline must be a static boolean."
+  },
+  "billing.maxCreditsPerRun": {
+    schema: import_typebox.Type.Number({ exclusiveMinimum: 0 }),
+    fixtures: {
+      valid: 1,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "cap" },
+      edition1: 1
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_billing_limit_invalid",
+    description: "Maximum Deepline credits permitted for one Play Run.",
+    errorMessage: "billing.maxCreditsPerRun must be a static number greater than 0. Remove it for no run cap."
+  },
+  "bindings.webhook.hmac.secretEnv": {
+    schema: SecretEnvironmentNameSchema,
+    fixtures: {
+      valid: "WEBHOOK_SECRET",
+      invalid: "webhook_secret",
+      absent: void 0,
+      unresolved: { expression: "secretEnv" },
+      edition1: "WEBHOOK_SECRET"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_webhook_hmac_invalid",
+    description: "Environment variable containing the webhook HMAC secret.",
+    errorMessage: "bindings.webhook.hmac.secretEnv must be an uppercase environment variable name beginning with a letter."
+  },
+  "bindings.webhook.hmac.algorithm": {
+    schema: import_typebox.Type.Literal("sha256"),
+    fixtures: {
+      valid: "sha256",
+      invalid: "sha1",
+      absent: void 0,
+      unresolved: { expression: "algorithm" },
+      edition1: "sha256"
+    },
+    referenceType: "'sha256'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_webhook_hmac_invalid",
+    description: "Webhook signature hash algorithm. Only sha256 is supported.",
+    errorMessage: 'bindings.webhook.hmac.algorithm must be the static literal "sha256".'
+  },
+  "bindings.webhook.hmac.header": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "x-signature",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "header" },
+      edition1: "x-signature"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_webhook_hmac_invalid",
+    description: "HTTP header containing the webhook signature.",
+    errorMessage: "bindings.webhook.hmac.header must be a non-empty static string."
+  },
+  "bindings.webhook.auth.type": {
+    schema: import_typebox.Type.Literal("standard-webhooks"),
+    fixtures: {
+      valid: "standard-webhooks",
+      invalid: "svix",
+      absent: void 0,
+      unresolved: { expression: "type" },
+      edition1: void 0
+    },
+    referenceType: "'standard-webhooks'",
+    // auth itself is optional; once present, the AST adapter requires this
+    // field together with headerFamily and signingSecrets.
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Uses the Standard Webhooks v1 symmetric signing scheme.",
+    errorMessage: 'bindings.webhook.auth.type must be the static literal "standard-webhooks".'
+  },
+  "bindings.webhook.auth.headerFamily": {
+    schema: import_typebox.Type.Union([import_typebox.Type.Literal("standard"), import_typebox.Type.Literal("svix")]),
+    fixtures: {
+      valid: "svix",
+      invalid: "webhook",
+      absent: void 0,
+      unresolved: { expression: "headerFamily" },
+      edition1: void 0
+    },
+    referenceType: "'standard' | 'svix'",
+    // auth itself is optional; once present, the AST adapter requires this
+    // field together with type and signingSecrets.
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Header namespace expected from the webhook provider.",
+    errorMessage: 'bindings.webhook.auth.headerFamily must be the static literal "standard" or "svix".'
+  },
+  "bindings.webhook.auth.signingSecrets[]": {
+    schema: SecretEnvironmentNameSchema,
+    fixtures: {
+      valid: "VECTOR_WEBHOOK_SECRET",
+      invalid: "vector_webhook_secret",
+      absent: void 0,
+      unresolved: { expression: "secret" },
+      edition1: void 0
+    },
+    referenceType: "string",
+    // auth itself is optional; once present, the AST adapter requires this
+    // field together with type and headerFamily.
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Deepline Secret name used to verify Standard Webhooks.",
+    errorMessage: "bindings.webhook.auth.signingSecrets entries must be uppercase Deepline Secret names beginning with a letter."
+  },
+  "bindings.webhook.auth.toleranceSeconds": {
+    schema: import_typebox.Type.Integer({ minimum: 1, maximum: 3600 }),
+    fixtures: {
+      valid: 300,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "toleranceSeconds" },
+      edition1: void 0
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_standard_webhooks_invalid",
+    description: "Accepted delivery timestamp skew in seconds, from 1 through 3600.",
+    errorMessage: "bindings.webhook.auth.toleranceSeconds must be a static whole number from 1 through 3600."
+  },
+  "bindings.cron.schedule": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "0 9 * * *",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "schedule" },
+      edition1: "0 9 * * *"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Five-field cron expression.",
+    errorMessage: "bindings.cron.schedule must be a non-empty static string."
+  },
+  "bindings.cron.timezone": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "UTC",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "timezone" },
+      edition1: "UTC"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_cron_timezone_invalid",
+    description: "IANA timezone. Omitted means UTC.",
+    errorMessage: "bindings.cron.timezone must be a valid non-empty IANA timezone string."
+  },
+  "bindings.sqlListeners": {
+    schema: import_typebox.Type.Array(import_typebox.Type.Object({}, { additionalProperties: true })),
+    fixtures: {
+      valid: [],
+      invalid: "listeners",
+      absent: void 0,
+      unresolved: { expression: "listeners" },
+      edition1: []
+    },
+    referenceType: "SqlListener[]",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Static provider-monitor listener declarations.",
+    errorMessage: "bindings.sqlListeners must be a static array of objects."
+  },
+  "bindings.sqlListeners[].id": {
+    schema: import_typebox.Type.String({ pattern: PLAY_SQL_LISTENER_ID_PATTERN.source }),
+    fixtures: {
+      valid: "job-openings",
+      invalid: "1-job-openings",
+      absent: void 0,
+      unresolved: { expression: "listenerId" },
+      edition1: "job-openings"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Unique static listener identifier within one Play.",
+    errorMessage: "bindings.sqlListeners[].id must begin with a letter and contain only letters, numbers, underscores, or hyphens."
+  },
+  "bindings.sqlListeners[].tool": {
+    schema: import_typebox.Type.String({ pattern: PLAY_SQL_LISTENER_TOOL_PATTERN.source }),
+    fixtures: {
+      valid: "deepline_native.company_radar",
+      invalid: "company_radar",
+      absent: void 0,
+      unresolved: { expression: "toolId" },
+      edition1: "deepline_native.company_radar"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Modeled provider monitor tool id in provider.tool form.",
+    errorMessage: "bindings.sqlListeners[].tool must use static provider.tool syntax."
+  },
+  "bindings.sqlListeners[].stream": {
+    schema: import_typebox.Type.String({ pattern: PLAY_SQL_LISTENER_ID_PATTERN.source }),
+    fixtures: {
+      valid: "company_job_openings",
+      invalid: "1-company-job-openings",
+      absent: void 0,
+      unresolved: { expression: "stream" },
+      edition1: "company_job_openings"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Static output stream key exposed by the monitor tool.",
+    errorMessage: "bindings.sqlListeners[].stream must be a static stream identifier."
+  },
+  "bindings.sqlListeners[].operations[]": {
+    schema: import_typebox.Type.Union([
+      import_typebox.Type.Literal("INSERT"),
+      import_typebox.Type.Literal("UPDATE"),
+      import_typebox.Type.Literal("DELETE")
+    ]),
+    fixtures: {
+      valid: "INSERT",
+      invalid: "UPSERT",
+      absent: void 0,
+      unresolved: { expression: "operation" },
+      edition1: "UPDATE"
+    },
+    referenceType: "'INSERT' | 'UPDATE' | 'DELETE'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Database operation that wakes the listener.",
+    errorMessage: "bindings.sqlListeners[].operations entries must be INSERT, UPDATE, or DELETE."
+  },
+  "bindings.sqlListeners[].where.before": {
+    schema: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Unknown()),
+    fixtures: {
+      valid: { status: { eq: "open" } },
+      invalid: "status=open",
+      absent: void 0,
+      unresolved: "beforeFilter",
+      edition1: { status: { eq: "open" } }
+    },
+    referenceType: "Record<string, SqlListenerFilterOperator>",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Column filters evaluated against the row before mutation.",
+    errorMessage: "bindings.sqlListeners[].where.before must be a static object keyed by column."
+  },
+  "bindings.sqlListeners[].where.after": {
+    schema: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Unknown()),
+    fixtures: {
+      valid: { status: { eq: "open" } },
+      invalid: "status=open",
+      absent: void 0,
+      unresolved: "afterFilter",
+      edition1: { status: { eq: "open" } }
+    },
+    referenceType: "Record<string, SqlListenerFilterOperator>",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Column filters evaluated against the row after mutation.",
+    errorMessage: "bindings.sqlListeners[].where.after must be a static object keyed by column."
+  },
+  "bindings.sqlListeners[].where.*.*.eq": {
+    schema: SqlListenerFilterScalarSchema,
+    fixtures: {
+      valid: "open",
+      invalid: { nested: true },
+      absent: void 0,
+      unresolved: { expression: "equalsValue" },
+      edition1: "open"
+    },
+    referenceType: "SqlListenerFilterScalar",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Scalar equality condition.",
+    errorMessage: "SQL listener eq must compare a scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.neq": {
+    schema: SqlListenerFilterScalarSchema,
+    fixtures: {
+      valid: "closed",
+      invalid: { nested: true },
+      absent: void 0,
+      unresolved: { expression: "notEqualsValue" },
+      edition1: "closed"
+    },
+    referenceType: "SqlListenerFilterScalar",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Scalar inequality condition.",
+    errorMessage: "SQL listener neq must compare a scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.in": {
+    schema: import_typebox.Type.Array(SqlListenerFilterScalarSchema, { minItems: 1 }),
+    fixtures: {
+      valid: ["open", "pending"],
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "acceptedValues" },
+      edition1: ["open"]
+    },
+    referenceType: "readonly SqlListenerFilterScalar[]",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Non-empty scalar membership condition.",
+    errorMessage: "SQL listener in must contain at least one scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.notIn": {
+    schema: import_typebox.Type.Array(SqlListenerFilterScalarSchema, { minItems: 1 }),
+    fixtures: {
+      valid: ["closed"],
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "rejectedValues" },
+      edition1: ["closed"]
+    },
+    referenceType: "readonly SqlListenerFilterScalar[]",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Non-empty scalar exclusion condition.",
+    errorMessage: "SQL listener notIn must contain at least one scalar value."
+  },
+  "bindings.sqlListeners[].where.*.*.isNull": {
+    schema: import_typebox.Type.Literal(true),
+    fixtures: {
+      valid: true,
+      invalid: false,
+      absent: void 0,
+      unresolved: { expression: "isNull" },
+      edition1: true
+    },
+    referenceType: "true",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Matches null values when set to true.",
+    errorMessage: "SQL listener isNull must be the static literal true."
+  },
+  "bindings.sqlListeners[].where.*.*.isNotNull": {
+    schema: import_typebox.Type.Literal(true),
+    fixtures: {
+      valid: true,
+      invalid: false,
+      absent: void 0,
+      unresolved: { expression: "isNotNull" },
+      edition1: true
+    },
+    referenceType: "true",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Matches non-null values when set to true.",
+    errorMessage: "SQL listener isNotNull must be the static literal true."
+  },
+  "bindings.sqlListeners[].where.*.*.ilike": {
+    schema: import_typebox.Type.String(),
+    fixtures: {
+      valid: "%software%",
+      invalid: 1,
+      absent: void 0,
+      unresolved: { expression: "pattern" },
+      edition1: "%software%"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "sql_listener_binding_shape",
+    description: "Case-insensitive SQL pattern condition.",
+    errorMessage: "SQL listener ilike must be a string pattern."
+  },
+  "bindings.secrets[]": {
+    schema: SecretEnvironmentNameSchema,
+    fixtures: {
+      valid: "API_TOKEN",
+      invalid: "api_token",
+      absent: void 0,
+      unresolved: { expression: "secret" },
+      edition1: "API_TOKEN"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_secret_invalid",
+    description: "Environment variable made available to the Play.",
+    errorMessage: "bindings.secrets entries must be uppercase environment variable names beginning with a letter."
+  },
+  "ctx.tools.execute.staleAfterSeconds": {
+    schema: import_typebox.Type.Union([import_typebox.Type.Null(), import_typebox.Type.Integer({ minimum: 0 })]),
+    fixtures: {
+      valid: 0,
+      invalid: -1,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: null
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "`0` always executes; `null`/omitted never expires; a positive integer is a TTL in seconds.",
+    errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
+  },
+  "ctx.tools.execute.id": {
+    schema: import_typebox.Type.String({ pattern: "\\S" }),
+    fixtures: {
+      valid: "company-enrichment",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "receiptId" },
+      edition1: "company-enrichment"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Stable durable receipt identity within one execution scope.",
+    errorMessage: "ctx.tools.execute id must be a non-empty string."
+  },
+  "ctx.tools.execute.tool": {
+    schema: import_typebox.Type.String({ pattern: "\\S" }),
+    fixtures: {
+      valid: "openmart_enrich_company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "toolId" },
+      edition1: "openmart_enrich_company"
+    },
+    referenceType: "K",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Integration tool id resolved against the generated ToolMap.",
+    errorMessage: "ctx.tools.execute tool must be a non-empty tool id."
+  },
+  "ctx.tools.execute.input": {
+    schema: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Unknown()),
+    fixtures: {
+      valid: { domain: "example.com" },
+      invalid: "example.com",
+      absent: void 0,
+      unresolved: "toolInput",
+      edition1: {}
+    },
+    referenceType: "K extends keyof ToolMap ? ToolMap[K]['input'] : Record<string, unknown>",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Tool-specific input object.",
+    errorMessage: "ctx.tools.execute input must be an object."
+  },
+  "ctx.tools.execute.description": {
+    schema: import_typebox.Type.String(),
+    fixtures: {
+      valid: "Enrich the company.",
+      invalid: 1,
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Enrich the company."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Human-readable purpose of the durable tool call.",
+    errorMessage: "ctx.tools.execute description must be a string."
+  },
+  "ctx.tools.execute.force": {
+    schema: import_typebox.Type.Boolean(),
+    fixtures: {
+      valid: true,
+      invalid: "true",
+      absent: void 0,
+      unresolved: { expression: "force" },
+      edition1: false
+    },
+    referenceType: "boolean",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Explicitly bypasses a completed durable tool receipt.",
+    errorMessage: "ctx.tools.execute force must be a boolean."
+  },
+  "ctx.tools.execute.timeoutMs": {
+    schema: import_typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 1,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "timeout" },
+      edition1: 1
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Positive whole-number runtime transport timeout in milliseconds.",
+    errorMessage: "timeoutMs must be a positive whole number of milliseconds."
+  },
+  "ctx.tools.execute.receiptWaitMs": {
+    schema: import_typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 1,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "receiptWait" },
+      edition1: 1
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Positive whole-number durable receipt wait budget in milliseconds.",
+    errorMessage: "receiptWaitMs must be a positive whole number of milliseconds."
+  },
+  "ctx.csv.options.description": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Load account rows.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Load rows."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Non-empty description for a staged CSV load.",
+    errorMessage: "ctx.csv options.description must be non-empty."
+  },
+  "ctx.csv.options.columns": {
+    schema: import_typebox.Type.Record(
+      import_typebox.Type.String(),
+      import_typebox.Type.Union([
+        import_typebox.Type.String({ minLength: 1 }),
+        import_typebox.Type.Array(import_typebox.Type.String({ minLength: 1 }), { minItems: 1 })
+      ])
+    ),
+    fixtures: {
+      valid: { domain: ["domain", "Company Domain"] },
+      invalid: { domain: [] },
+      absent: void 0,
+      unresolved: { expression: { dynamic: true } },
+      edition1: { domain: "domain" }
+    },
+    referenceType: "CsvRenameMap",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Canonical field-to-header aliases for a staged CSV.",
+    errorMessage: "ctx.csv options.columns values must be a non-empty header or alias list."
+  },
+  "ctx.csv.options.rename": {
+    schema: import_typebox.Type.Record(
+      import_typebox.Type.String(),
+      import_typebox.Type.Union([
+        import_typebox.Type.String({ minLength: 1 }),
+        import_typebox.Type.Array(import_typebox.Type.String({ minLength: 1 }), { minItems: 1 })
+      ])
+    ),
+    fixtures: {
+      valid: { domain: "Company Domain" },
+      invalid: { domain: "" },
+      absent: void 0,
+      unresolved: { expression: { dynamic: true } },
+      edition1: { domain: "domain" }
+    },
+    referenceType: "CsvRenameMap",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Legacy header rename aliases for a staged CSV.",
+    errorMessage: "ctx.csv options.rename values must be a non-empty header or alias list."
+  },
+  "ctx.csv.options.required": {
+    schema: import_typebox.Type.Array(import_typebox.Type.String({ minLength: 1 })),
+    fixtures: {
+      valid: ["domain"],
+      invalid: [""],
+      absent: void 0,
+      unresolved: { expression: "requiredColumns" },
+      edition1: []
+    },
+    referenceType: "readonly string[]",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_csv_option_invalid",
+    description: "Canonical columns required after CSV normalization.",
+    errorMessage: "ctx.csv options.required entries must be non-empty column names."
+  },
+  "ctx.dataset.key": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "accounts",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "datasetKey" },
+      edition1: "rows"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Stable durable identity for one dataset.",
+    errorMessage: "ctx.dataset key must be a non-empty static string."
+  },
+  "ctx.dataset.run.description": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich account rows.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Process rows."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Non-empty description for one dataset execution.",
+    errorMessage: "ctx.dataset run description must be non-empty."
+  },
+  "ctx.dataset.run.key": {
+    schema: import_typebox.Type.Union([
+      import_typebox.Type.String({ minLength: 1 }),
+      import_typebox.Type.Array(import_typebox.Type.String({ minLength: 1 }), { minItems: 1 }),
+      import_typebox.Type.Function(
+        [import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Unknown()), import_typebox.Type.Integer()],
+        import_typebox.Type.Union([
+          import_typebox.Type.String(),
+          import_typebox.Type.Number(),
+          import_typebox.Type.Readonly(import_typebox.Type.Array(import_typebox.Type.Unknown()))
+        ])
+      )
+    ]),
+    fixtures: {
+      valid: (row) => String(row.domain),
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "rowKey" },
+      edition1: ["domain"]
+    },
+    referenceType: "DatasetRowKey<InputRow>",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Stable field or fields used for durable row identity.",
+    errorMessage: "ctx.dataset run key must be a non-empty field, field list, or key function."
+  },
+  "ctx.dataset.run.onRowError": {
+    schema: import_typebox.Type.Union([import_typebox.Type.Literal("isolate"), import_typebox.Type.Literal("fail")]),
+    fixtures: {
+      valid: "isolate",
+      invalid: "continue",
+      absent: void 0,
+      unresolved: { expression: "rowErrorPolicy" },
+      edition1: "fail"
+    },
+    referenceType: "'isolate' | 'fail'",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Whether row failures isolate or fail the whole dataset.",
+    errorMessage: 'ctx.dataset run onRowError must be "isolate" or "fail".'
+  },
+  "ctx.dataset.run.mode": {
+    schema: import_typebox.Type.Union([import_typebox.Type.Literal("upsert"), import_typebox.Type.Literal("net_new")]),
+    fixtures: {
+      valid: "upsert",
+      invalid: "append",
+      absent: void 0,
+      unresolved: { expression: "datasetMode" },
+      edition1: "upsert"
+    },
+    referenceType: "'upsert' | 'net_new'",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Whether the dataset returns all rows or only newly admitted rows.",
+    errorMessage: 'ctx.dataset run mode must be "upsert" or "net_new".'
+  },
+  "ctx.dataset.run.undrawnColumns": {
+    schema: import_typebox.Type.Array(import_typebox.Type.String({ minLength: 1 }), { minItems: 1 }),
+    fixtures: {
+      valid: ["miss_reason"],
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "undrawnColumns" },
+      edition1: ["miss_reason"]
+    },
+    referenceType: "readonly string[]",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Computed columns deliberately left out of the authored @mermaid diagram.",
+    errorMessage: "ctx.dataset run undrawnColumns must be a non-empty array of static column-name strings."
+  },
+  "ctx.step.id": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "load-settings",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "stepId" },
+      edition1: "step"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Stable durable identity for one scalar checkpoint.",
+    errorMessage: "ctx.step id must be a non-empty static string."
+  },
+  "ctx.step.semanticKey": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "account:stripe.com",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "semanticKey" },
+      edition1: "account"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Optional semantic receipt identity for a scalar checkpoint.",
+    errorMessage: "ctx.step semanticKey must be a non-empty string."
+  },
+  "ctx.step.staleAfterSeconds": {
+    schema: import_typebox.Type.Union([import_typebox.Type.Null(), import_typebox.Type.Integer({ minimum: 0 })]),
+    fixtures: {
+      valid: 0,
+      invalid: -1,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: null
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Checkpoint freshness: null/omitted never expires, 0 always executes.",
+    errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
+  },
+  "ctx.fetch.key": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "notify-crm",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "fetchKey" },
+      edition1: "fetch"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "static-required",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Stable durable identity for one external HTTP request.",
+    errorMessage: "ctx.fetch key must be a non-empty static string.",
+    unresolvedHint: PLAY_AUTHORING_STATIC_FETCH_KEY_HINT
+  },
+  "ctx.fetch.staleAfterSeconds": {
+    schema: import_typebox.Type.Union([import_typebox.Type.Null(), import_typebox.Type.Integer({ minimum: 0 })]),
+    fixtures: {
+      valid: null,
+      invalid: 1.5,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: 0
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Fetch freshness: null/omitted never expires, 0 always executes.",
+    errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
+  },
+  "ctx.runPlay.key": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "enrich-company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "callKey" },
+      edition1: "child"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Stable identity for one inline child Play call.",
+    errorMessage: "ctx.runPlay key must be a non-empty string."
+  },
+  "ctx.runPlay.playRef": {
+    schema: import_typebox.Type.Union([
+      import_typebox.Type.String({ minLength: 1 }),
+      import_typebox.Type.Union([
+        import_typebox.Type.Object(
+          { playName: import_typebox.Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        ),
+        import_typebox.Type.Object(
+          { name: import_typebox.Type.String({ minLength: 1 }) },
+          { additionalProperties: true }
+        )
+      ])
+    ]),
+    fixtures: {
+      valid: "prebuilt/company-lookup",
+      invalid: {},
+      absent: void 0,
+      unresolved: { expression: "playRef" },
+      edition1: { name: "company-lookup" }
+    },
+    referenceType: "string | PlayReferenceLike",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Child Play name or typed Play definition handle.",
+    errorMessage: "ctx.runPlay playRef must be a non-empty Play name or definition handle."
+  },
+  "ctx.runPlay.input": {
+    schema: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Unknown()),
+    fixtures: {
+      valid: { domain: "example.com" },
+      invalid: "example.com",
+      absent: void 0,
+      unresolved: "childInput",
+      edition1: {}
+    },
+    referenceType: "Record<string, unknown>",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Scalar input object submitted to the child Play.",
+    errorMessage: "ctx.runPlay input must be an object."
+  },
+  "ctx.runPlay.options.description": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich the company.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Run child."
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Non-empty purpose for one inline child Play call.",
+    errorMessage: "ctx.runPlay options.description must be non-empty."
+  },
+  "ctx.runPlay.options.execution": {
+    schema: import_typebox.Type.Literal("inline"),
+    fixtures: {
+      valid: "inline",
+      invalid: "child-workflow",
+      absent: void 0,
+      unresolved: { expression: "execution" },
+      edition1: "inline"
+    },
+    referenceType: "'inline'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Child composition strategy. Only inline is supported.",
+    errorMessage: 'ctx.runPlay execution must be "inline".'
+  },
+  "ctx.runPlay.options.timeoutMs": {
+    schema: import_typebox.Type.Undefined(),
+    fixtures: {
+      valid: void 0,
+      invalid: 1e3,
+      absent: void 0,
+      unresolved: { expression: "timeoutMs" },
+      edition1: void 0
+    },
+    referenceType: "never",
+    required: false,
+    resolution: "unsupported",
+    issueCode: "play_authoring_run_play_option_invalid",
+    description: "Unsupported legacy child-workflow timeout.",
+    errorMessage: "ctx.runPlay timeoutMs is unsupported because child Plays execute inline."
+  },
+  "runtime.timeout": {
+    schema: import_typebox.Type.String({ pattern: "^\\d+\\s*[mh]$" }),
+    fixtures: {
+      valid: "90m",
+      invalid: "90s",
+      absent: void 0,
+      unresolved: { expression: "timeout" },
+      edition1: "90m"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Play-level sandbox deadline. The default is 30m; use a static duration such as 90m or 2h, up to 4h.",
+    errorMessage: 'runtime.timeout must be a static duration such as "90m" or "2h".'
+  },
+  "runtime.size": {
+    schema: import_typebox.Type.Literal("standard"),
+    fixtures: {
+      valid: "standard",
+      invalid: "large",
+      absent: void 0,
+      unresolved: { expression: "size" },
+      edition1: "standard"
+    },
+    referenceType: "'standard'",
+    required: false,
+    resolution: "static-required",
+    issueCode: "play_authoring_binding_invalid",
+    description: "Deepline-managed sandbox size. Only standard is supported.",
+    errorMessage: 'runtime.size must be the static literal "standard".'
+  },
+  "ctx.customerDb.query.statement": {
+    schema: import_typebox.Type.Union([
+      import_typebox.Type.String({ minLength: 1 }),
+      import_typebox.Type.Object(
+        {
+          kind: import_typebox.Type.Optional(import_typebox.Type.Literal("sql.query")),
+          text: import_typebox.Type.String({ minLength: 1 }),
+          values: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.Unknown(), { maxItems: 0 }))
+        },
+        { additionalProperties: false }
+      )
+    ]),
+    fixtures: {
+      valid: { kind: "sql.query", text: "select 1", values: [] },
+      invalid: { kind: "sql.query", text: "select $1", values: [1] },
+      absent: void 0,
+      unresolved: { expression: "statement" },
+      edition1: "select 1"
+    },
+    referenceType: "SqlQuery",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "One non-empty Customer DB SQL string; the deprecated SqlQuery object is accepted only without parameter values.",
+    errorMessage: "ctx.customerDb.query statement must be a non-empty SQL string. Deprecated SqlQuery objects cannot contain parameter values."
+  },
+  "ctx.customerDb.query.options.maxRows": {
+    schema: import_typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 100,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "maxRows" },
+      edition1: 100
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Positive whole-number Customer DB response row limit.",
+    errorMessage: "ctx.customerDb.query options.maxRows must be a positive whole number."
+  },
+  "ctx.customerDb.query.options.timeoutMs": {
+    schema: import_typebox.Type.Integer({ minimum: 1 }),
+    fixtures: {
+      valid: 1e3,
+      invalid: 0,
+      absent: void 0,
+      unresolved: { expression: "timeoutMs" },
+      edition1: 1e3
+    },
+    referenceType: "number",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Positive whole-number Customer DB timeout in milliseconds.",
+    errorMessage: "ctx.customerDb.query options.timeoutMs must be a positive whole number of milliseconds."
+  },
+  "ctx.tool.key": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "key" },
+      edition1: "tool"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Stable receipt identity for the tool shorthand.",
+    errorMessage: "ctx.tool key must be a non-empty string."
+  },
+  "ctx.tool.tool": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "openmart_enrich_company",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "tool" },
+      edition1: "openmart_enrich_company"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Integration tool id for the tool shorthand.",
+    errorMessage: "ctx.tool tool must be a non-empty tool id."
+  },
+  "ctx.tool.input": {
+    schema: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Unknown()),
+    fixtures: {
+      valid: { domain: "example.com" },
+      invalid: "example.com",
+      absent: void 0,
+      unresolved: "toolInput",
+      edition1: {}
+    },
+    referenceType: "Record<string, unknown>",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Tool-specific input object for the shorthand.",
+    errorMessage: "ctx.tool input must be an object."
+  },
+  "ctx.tool.options.description": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Enrich the company.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Run tool."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Non-empty purpose for the tool shorthand.",
+    errorMessage: "ctx.tool options.description must be non-empty."
+  },
+  "ctx.runSteps.options.description": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "Score the account.",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "description" },
+      edition1: "Run steps."
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Non-empty purpose for a reusable step program.",
+    errorMessage: "ctx.runSteps options.description must be non-empty."
+  },
+  "ctx.sleep.ms": {
+    schema: import_typebox.Type.Integer({ minimum: 0 }),
+    fixtures: {
+      valid: 0,
+      invalid: -1,
+      absent: void 0,
+      unresolved: { expression: "delayMs" },
+      edition1: 1e3
+    },
+    referenceType: "number",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_step_option_invalid",
+    description: "Non-negative whole-number sleep duration in milliseconds.",
+    errorMessage: "ctx.sleep ms must be a non-negative whole number."
+  },
+  "ctx.fetch.url": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "https://example.com",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "url" },
+      edition1: "https://example.com"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_fetch_secret_requires_tls",
+    description: "HTTP request URL. Secret authentication requires HTTPS.",
+    errorMessage: "ctx.fetch URL must be a non-empty URL string."
+  },
+  "ctx.fetch.init.method": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "GET",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "method" },
+      edition1: "GET"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_fetch_idempotency_required",
+    description: "HTTP method. Mutating methods require an Idempotency-Key.",
+    errorMessage: "ctx.fetch method must be a non-empty string."
+  },
+  "ctx.fetch.init.headers.Idempotency-Key": {
+    schema: import_typebox.Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: "contact-123-update",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "idempotencyKey" },
+      edition1: "contact-123-update"
+    },
+    referenceType: "string",
+    required: false,
+    resolution: "runtime-allowed",
+    issueCode: "play_authoring_fetch_idempotency_required",
+    description: "Required for mutating HTTP methods to make replay safe.",
+    errorMessage: "Idempotency-Key must be a non-empty string when provided."
+  }
+};
+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 PlayBindings = {",
+  `  description?: ${cloudReferenceType("description")};`,
+  `  compatibility?: { 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")}; 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")} };`,
+  "  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 RuntimeStepOptions = { semanticKey?: ${cloudReferenceType("ctx.step.semanticKey")}; staleAfterSeconds?: ${cloudReferenceType("ctx.step.staleAfterSeconds")} };`,
+  `export type FetchOptions = { staleAfterSeconds?: ${cloudReferenceType("ctx.fetch.staleAfterSeconds")}; transient?: boolean };`,
+  "export type PlayFetchResponse = { ok: boolean; status: number; statusText: string; url: string; headers: Record<string, string>; bodyText: string; json: unknown | null };",
+  "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?: number };",
+  "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>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output, Value>): StepProgram<Input, Output & Record<Name, Value | null>, 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?: number; 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>; 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<Program extends StepProgram<OutputRow, object, unknown>>(program: Program): DatasetBuilder<InputRow, StepProgramOutput<Program>>;",
+  "  step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;",
+  "  run(options?: DatasetRunOptions<InputRow>): Promise<PlayDataset<OutputRow>>;",
+  "};",
+  "export type PlayReferenceLike = { readonly playName: string; readonly name?: string } | { readonly name: string; readonly playName?: string };",
+  "export interface DeeplinePlayRuntimeContext {",
+  "  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")} }): 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?: { 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")} }): 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>;`,
+  "  log(message: string): void;",
+  `  sleep(ms: ${cloudReferenceType("ctx.sleep.ms")}): Promise<void>;`,
+  "}",
+  "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings; billing?: PlayBindings['billing']; runtime?: PlayBindings['runtime']; compatibility?: PlayBindings['compatibility'] };",
+  "export type DefinedPlay<TInput, TOutput extends PlayReturnObject> = ((ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>) & { readonly name: string; readonly __inputType?: TInput; readonly __outputType?: TOutput; readonly runtime?: PlayBindings['runtime']; readonly compatibility?: PlayBindings['compatibility'] };"
+];
+
 // ../play-runtime/query-result-dataset.ts
 var QUERY_RESULT_DATASET_PAGE_SIZE = 1e3;
 function isCustomerDbDatasetTool(toolId) {
@@ -9072,6 +10353,122 @@ function getDefinedPlayMetadata(value) {
   return candidate;
 }
 
+// src/monitors.ts
+function defineMonitor(definition) {
+  if (!definition || typeof definition !== "object") {
+    throw new Error("defineMonitor(definition) requires a definition object.");
+  }
+  const key = typeof definition.key === "string" ? definition.key.trim() : "";
+  if (!key) {
+    throw new Error('defineMonitor(definition) requires a non-empty "key".');
+  }
+  const tool = typeof definition.tool === "string" ? definition.tool.trim() : "";
+  if (!tool) {
+    throw new Error(
+      'defineMonitor(definition) requires a non-empty monitor tool id in "tool" (e.g. "deepline_native.company_radar").'
+    );
+  }
+  if (!definition.payload || typeof definition.payload !== "object" || Array.isArray(definition.payload)) {
+    throw new Error(
+      'defineMonitor(definition) requires "payload" to be a JSON object.'
+    );
+  }
+  if (definition.name !== void 0 && typeof definition.name !== "string") {
+    throw new Error('defineMonitor(definition) "name" must be a string.');
+  }
+  if (definition.controls !== void 0 && (typeof definition.controls !== "object" || Array.isArray(definition.controls))) {
+    throw new Error(
+      'defineMonitor(definition) "controls" must be a JSON object.'
+    );
+  }
+  return definition;
+}
+
+// ../plays/bootstrap-routes.ts
+var DEEPLINE_TOOL_CATEGORIES = [
+  "company_search",
+  "people_search",
+  "people_enrich",
+  "email_finder",
+  "email_verify",
+  "phone_finder",
+  "phone_verify",
+  "identity_resolution",
+  "reverse_lookup",
+  "enrichment",
+  "batch",
+  "premium",
+  "free"
+];
+var PLAY_BOOTSTRAP_TEMPLATES = [
+  "people-list",
+  "company-list",
+  "people-email",
+  "people-phone",
+  "company-people",
+  "company-people-email",
+  "company-people-phone"
+];
+var PLAY_BOOTSTRAP_SOURCE_KINDS = [
+  "csv",
+  "play",
+  "provider",
+  "providers"
+];
+var PLAY_BOOTSTRAP_STAGE_KINDS = [
+  "play",
+  "provider",
+  "providers"
+];
+var PLAY_BOOTSTRAP_FINDER_KINDS = [
+  "email_finder",
+  "phone_finder"
+];
+var PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY = "company_search";
+var PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY = "people_search";
+var PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER = {
+  email_finder: "email_finder",
+  phone_finder: "phone_finder"
+};
+var PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER = {
+  email_finder: "email",
+  phone_finder: "phone"
+};
+var PLAY_BOOTSTRAP_CONTACT_FIELDS = [
+  "first_name",
+  "last_name",
+  "domain",
+  "company_name",
+  "linkedin_url",
+  "title",
+  "email",
+  "phone"
+];
+var PLAY_BOOTSTRAP_COMPANY_FIELDS = [
+  "domain",
+  "company_domain",
+  "company_name",
+  "linkedin_url",
+  "website"
+];
+function isPlayBootstrapFinderKind(value) {
+  return PLAY_BOOTSTRAP_FINDER_KINDS.includes(value);
+}
+function isPlayBootstrapTemplate(value) {
+  return PLAY_BOOTSTRAP_TEMPLATES.includes(value);
+}
+function formatPlayBootstrapFinderKinds() {
+  return PLAY_BOOTSTRAP_FINDER_KINDS.join("|");
+}
+function formatPlayBootstrapTemplates() {
+  return PLAY_BOOTSTRAP_TEMPLATES.join("|");
+}
+function formatPlayBootstrapFinderKindsForSentence() {
+  const allButLast = PLAY_BOOTSTRAP_FINDER_KINDS.slice(0, -1);
+  const last = PLAY_BOOTSTRAP_FINDER_KINDS.at(-1);
+  return `${allButLast.join(", ")} or ${last}`;
+}
+
 // src/tool-output.ts
 var import_node_fs3 = require("fs");
 var import_node_os3 = require("os");
@@ -9260,6 +10657,7 @@ function extractSummaryFields(payload) {
 0 && (module.exports = {
   AuthError,
   ConfigError,
+  CtxFetchHttpError,
   DEEPLINE_EXTRACTOR_TARGETS,
   DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS,
   DEEPLINE_TOOL_CATEGORIES,