deepline 0.3.89 → 0.3.90

package/dist/monitor-fleet-contract.mjs

@@ -0,0 +1,367 @@
+// src/monitor-fleet-contract.ts
+var MONITOR_FLEET_MAX_MEMBERS = 1e3;
+var MONITOR_FLEET_FRONTIER_MAX_ROWS = 1e4;
+var MONITOR_FLEET_AUTHORING_CONTRACT_EDITION = 1;
+var SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS = [
+  MONITOR_FLEET_AUTHORING_CONTRACT_EDITION
+];
+var MONITOR_FLEET_AUTHORING_CONTRACT_CHANGELOG = [
+  {
+    edition: 1,
+    changed: "Initial Fleet JSON contract: bounded sticky table membership, one daily sync, and a seven-day removal grace.",
+    compatibilityOwner: "Monitors Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
+  }
+];
+var MONITOR_FLEET_REMOVAL_GRACE_MS = 7 * 24 * 60 * 6e4;
+var MONITOR_FLEET_DOCUMENTATION = {
+  summary: "A Monitor Fleet keeps one bounded, sticky set of ordinary monitors aligned with Customer DB rows.",
+  authoredFields: {
+    id: "Stable lowercase fleet id used by sync, get, and deactivate.",
+    source: "Customer DB table, unique row key, and optional equality filters that select candidate rows.",
+    member: "Ordinary monitor tool, stable key template, and payload evaluated for each selected source row.",
+    selection: "Deterministic ranking and an active-member limit between 1 and 1,000."
+  },
+  fixedPolicy: {
+    cadence: "daily",
+    membership: "sticky",
+    removalGrace: "7d",
+    onRemoved: "deactivate",
+    ownership: "A Fleet may adopt a same-tool ordinary monitor with its deterministic member key. The first Fleet claim wins; another Fleet or a different tool receives a conflict.",
+    billing: "No Fleet fee, permit, or renewal. Dry-run reports ordinary monitor lifecycle charges due now."
+  },
+  stickyMembership: "Ranking fills vacancies but never replaces a current member merely because another row ranks higher.",
+  columnExpression: 'Use { "$fleet": "column", "name": "column_name" } in a member key or payload to read a value from each source row.'
+};
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function identifier(value) {
+  return typeof value === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+function exactKeys(input, keys, path, issues) {
+  if (!input) return;
+  for (const key of Object.keys(input)) {
+    if (keys.includes(key)) continue;
+    issues.push({
+      path: path ? `${path}.${key}` : key,
+      code: "unknown_fleet_field",
+      message: `${path || "Fleet"} does not accept '${key}'.`
+    });
+  }
+}
+function jsonValue(value, path, issues) {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => jsonValue(item, `${path}.${index}`, issues));
+    return;
+  }
+  const input = record(value);
+  if (!input) {
+    issues.push({
+      path,
+      code: "invalid_fleet_json_value",
+      message: "Fleet payload values must be JSON values."
+    });
+    return;
+  }
+  for (const [key, item] of Object.entries(input)) {
+    jsonValue(item, `${path}.${key}`, issues);
+  }
+}
+function fleetColumn(name) {
+  if (!identifier(name)) throw new Error(`Invalid fleet column '${name}'.`);
+  return { $fleet: "column", name };
+}
+function fleetKey(...parts) {
+  if (parts.length === 0)
+    throw new Error("A fleet key needs at least one part.");
+  return { $fleet: "template", parts };
+}
+function defineMonitorFleet(definition) {
+  return definition;
+}
+function validateExpression(value, path, issues) {
+  const input = record(value);
+  if (!input || input.$fleet !== "column" || !identifier(input.name)) {
+    issues.push({
+      path,
+      code: "invalid_fleet_expression",
+      message: "Fleet expressions must be an exact tagged column reference."
+    });
+    return;
+  }
+  exactKeys(input, ["$fleet", "name"], path, issues);
+}
+function walkPayload(value, path, issues) {
+  if (Array.isArray(value)) {
+    value.forEach(
+      (item, index) => walkPayload(item, `${path}.${index}`, issues)
+    );
+    return;
+  }
+  const input = record(value);
+  if (!input) return;
+  if ("$fleet" in input) {
+    validateExpression(input, path, issues);
+    return;
+  }
+  for (const [key, item] of Object.entries(input)) {
+    walkPayload(item, `${path}.${key}`, issues);
+  }
+}
+function validateMonitorFleetDefinition(value) {
+  const issues = [];
+  const input = record(value);
+  if (!input) {
+    return {
+      valid: false,
+      issues: [
+        {
+          path: "",
+          code: "invalid_fleet",
+          message: "Fleet must be an object."
+        }
+      ]
+    };
+  }
+  exactKeys(input, ["id", "source", "member", "selection"], "", issues);
+  if (typeof input.id !== "string" || !/^[a-z][a-z0-9-]{0,199}$/.test(input.id)) {
+    issues.push({
+      path: "id",
+      code: "invalid_fleet_id",
+      message: "Fleet id must be lowercase kebab-case."
+    });
+  }
+  const source = record(input.source);
+  exactKeys(
+    source,
+    ["kind", "schema", "table", "key", "where"],
+    "source",
+    issues
+  );
+  if (!source || source.kind !== "customer_db_table") {
+    issues.push({
+      path: "source.kind",
+      code: "invalid_fleet_source",
+      message: "Beta fleets require customer_db_table."
+    });
+  }
+  if (!identifier(source?.schema) || !identifier(source?.table)) {
+    issues.push({
+      path: "source",
+      code: "invalid_fleet_table",
+      message: "Source schema and table must be SQL identifiers."
+    });
+  }
+  const sourceKey = record(source?.key);
+  exactKeys(sourceKey, ["column", "type"], "source.key", issues);
+  if (!sourceKey || !identifier(sourceKey.column) || !["text", "uuid", "int4", "int8"].includes(String(sourceKey.type))) {
+    issues.push({
+      path: "source.key",
+      code: "invalid_fleet_source_key",
+      message: "Source key must name a supported typed column."
+    });
+  }
+  if (source?.where !== void 0) {
+    const where = record(source.where);
+    if (!where) {
+      issues.push({
+        path: "source.where",
+        code: "invalid_fleet_where",
+        message: "source.where must be an object of equality values."
+      });
+    } else {
+      for (const [column, expected] of Object.entries(where)) {
+        if (!identifier(column)) {
+          issues.push({
+            path: `source.where.${column}`,
+            code: "invalid_fleet_where_column",
+            message: "source.where keys must be SQL identifiers."
+          });
+        }
+        if (expected !== null && typeof expected !== "string" && typeof expected !== "boolean" && !(typeof expected === "number" && Number.isFinite(expected))) {
+          issues.push({
+            path: `source.where.${column}`,
+            code: "invalid_fleet_where_value",
+            message: "source.where values must be finite JSON scalars or null."
+          });
+        }
+      }
+    }
+  }
+  const member = record(input.member);
+  exactKeys(member, ["tool", "key", "payload"], "member", issues);
+  const key = record(member?.key);
+  if (!member || typeof member.tool !== "string" || !member.tool.trim()) {
+    issues.push({
+      path: "member.tool",
+      code: "invalid_fleet_tool",
+      message: "Member tool is required."
+    });
+  }
+  if (!key || key.$fleet !== "template" || !Array.isArray(key.parts) || key.parts.length === 0) {
+    issues.push({
+      path: "member.key",
+      code: "invalid_fleet_key",
+      message: "Member key must be a tagged fleet template."
+    });
+  } else {
+    exactKeys(key, ["$fleet", "parts"], "member.key", issues);
+    for (const [index, part] of key.parts.entries()) {
+      if (typeof part !== "string")
+        validateExpression(part, `member.key.parts.${index}`, issues);
+    }
+    if (sourceKey && !key.parts.some(
+      (part) => record(part)?.$fleet === "column" && record(part)?.name === sourceKey.column
+    )) {
+      issues.push({
+        path: "member.key.parts",
+        code: "fleet_key_missing_source_key",
+        message: "Member key must include the source key column."
+      });
+    }
+  }
+  if (!member || !("payload" in member)) {
+    issues.push({
+      path: "member.payload",
+      code: "invalid_fleet_payload",
+      message: "Member payload is required."
+    });
+  } else {
+    jsonValue(member.payload, "member.payload", issues);
+  }
+  walkPayload(member?.payload, "member.payload", issues);
+  const selection = record(input.selection);
+  exactKeys(selection, ["limit", "orderBy", "membership"], "selection", issues);
+  if (!selection || !Number.isSafeInteger(selection.limit) || Number(selection.limit) < 1 || Number(selection.limit) > MONITOR_FLEET_MAX_MEMBERS) {
+    issues.push({
+      path: "selection.limit",
+      code: "MONITOR_FLEET_LIMIT_EXCEEDED",
+      message: "selection.limit must be between 1 and 1,000."
+    });
+  }
+  if (selection?.membership !== "sticky") {
+    issues.push({
+      path: "selection.membership",
+      code: "invalid_fleet_membership",
+      message: `Fleet membership is fixed to ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.membership}. ${MONITOR_FLEET_DOCUMENTATION.stickyMembership}`
+    });
+  }
+  const orderBy = selection?.orderBy;
+  if (!Array.isArray(orderBy) || orderBy.length === 0) {
+    issues.push({
+      path: "selection.orderBy",
+      code: "invalid_fleet_order",
+      message: "At least one deterministic order field is required."
+    });
+  } else {
+    const orderColumns = /* @__PURE__ */ new Set();
+    for (const [index, order] of orderBy.entries()) {
+      const item = record(order);
+      exactKeys(
+        item,
+        ["column", "direction"],
+        `selection.orderBy.${index}`,
+        issues
+      );
+      if (!item || !identifier(item.column) || !["asc", "desc"].includes(String(item.direction))) {
+        issues.push({
+          path: `selection.orderBy.${index}`,
+          code: "invalid_fleet_order",
+          message: "Order fields need a column and asc/desc direction."
+        });
+      } else if (orderColumns.has(item.column)) {
+        issues.push({
+          path: `selection.orderBy.${index}.column`,
+          code: "duplicate_fleet_order_column",
+          message: "Each selection order column may appear only once."
+        });
+      } else {
+        orderColumns.add(item.column);
+      }
+    }
+    if (sourceKey && record(orderBy.at(-1))?.column !== sourceKey.column) {
+      issues.push({
+        path: "selection.orderBy",
+        code: "fleet_order_missing_key",
+        message: "The final order field must be the source key."
+      });
+    }
+  }
+  for (const removedOption of ["spendLimits", "lifecycle", "reconciliation"]) {
+    if (removedOption in input) {
+      issues.push({
+        path: removedOption,
+        code: "unsupported_fleet_option",
+        message: `${removedOption} is fixed by Monitor Fleets and must be omitted. Fleets sync ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.cadence} and ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.onRemoved} members after ${MONITOR_FLEET_DOCUMENTATION.fixedPolicy.removalGrace} absent from the source.`
+      });
+    }
+  }
+  return issues.length === 0 ? { valid: true, definition: value, issues } : { valid: false, issues };
+}
+function admitMonitorFleetAuthoringContract(value, edition = MONITOR_FLEET_AUTHORING_CONTRACT_EDITION) {
+  if (!SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS.includes(
+    edition
+  )) {
+    return {
+      valid: false,
+      issues: [
+        {
+          path: "authoring_contract_edition",
+          code: "unsupported_fleet_authoring_contract_edition",
+          message: `Monitor Fleet authoring contract edition ${edition} is not supported.`
+        }
+      ]
+    };
+  }
+  const result = validateMonitorFleetDefinition(value);
+  return result.valid && result.definition ? {
+    valid: true,
+    contract: {
+      edition,
+      // JSON cloning prevents later caller mutation from changing the
+      // admitted snapshot.
+      definition: JSON.parse(
+        JSON.stringify(result.definition)
+      )
+    },
+    issues: []
+  } : { valid: false, issues: result.issues };
+}
+function evaluateMonitorFleetValue(value, row) {
+  if (Array.isArray(value))
+    return value.map((item) => evaluateMonitorFleetValue(item, row));
+  const input = record(value);
+  if (!input) return value;
+  if (input.$fleet === "column") return row[String(input.name)];
+  if (input.$fleet === "template" && Array.isArray(input.parts)) {
+    return input.parts.map(
+      (part) => typeof part === "string" ? part : String(evaluateMonitorFleetValue(part, row) ?? "")
+    ).join("");
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([key, item]) => [
+      key,
+      evaluateMonitorFleetValue(item, row)
+    ])
+  );
+}
+export {
+  MONITOR_FLEET_AUTHORING_CONTRACT_CHANGELOG,
+  MONITOR_FLEET_AUTHORING_CONTRACT_EDITION,
+  MONITOR_FLEET_DOCUMENTATION,
+  MONITOR_FLEET_FRONTIER_MAX_ROWS,
+  MONITOR_FLEET_MAX_MEMBERS,
+  MONITOR_FLEET_REMOVAL_GRACE_MS,
+  SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS,
+  admitMonitorFleetAuthoringContract,
+  defineMonitorFleet,
+  evaluateMonitorFleetValue,
+  fleetColumn,
+  fleetKey,
+  validateMonitorFleetDefinition
+};

package/dist/plays/bundle-play-file.d.mts

@@ -1,6 +1,6 @@
 /// <reference path="./text-imports.d.ts" />
-import { P as PlayArtifactKind, a as PlayBundleArtifact, b as PlaySandboxRuntimeDeclaration, c as PlayCompilerManifest } from '../compiler-manifest-DsLbQaew.mjs';
-export { d as PLAY_ARTIFACT_KINDS, e as PlayArtifactCompatibility, f as PlayImportPolicy, g as PlayPackageImport, h as PlayRuntimeFeature } from '../compiler-manifest-DsLbQaew.mjs';
+import { ae as PlayArtifactKind, af as PlayBundleArtifact, ag as PlaySandboxRuntimeDeclaration, P as PlayCompilerManifest } from '../compiler-manifest-BaJfE-5H.mjs';
+export { ah as PLAY_ARTIFACT_KINDS, ai as PlayArtifactCompatibility, aj as PlayImportPolicy, ak as PlayPackageImport, al as PlayRuntimeFeature } from '../compiler-manifest-BaJfE-5H.mjs';
 import '@sinclair/typebox';
 
 type ImportedPlayDependency = {

package/dist/plays/bundle-play-file.d.ts

@@ -1,6 +1,6 @@
 /// <reference path="./text-imports.d.ts" />
-import { P as PlayArtifactKind, a as PlayBundleArtifact, b as PlaySandboxRuntimeDeclaration, c as PlayCompilerManifest } from '../compiler-manifest-DsLbQaew.js';
-export { d as PLAY_ARTIFACT_KINDS, e as PlayArtifactCompatibility, f as PlayImportPolicy, g as PlayPackageImport, h as PlayRuntimeFeature } from '../compiler-manifest-DsLbQaew.js';
+import { ae as PlayArtifactKind, af as PlayBundleArtifact, ag as PlaySandboxRuntimeDeclaration, P as PlayCompilerManifest } from '../compiler-manifest-BaJfE-5H.js';
+export { ah as PLAY_ARTIFACT_KINDS, ai as PlayArtifactCompatibility, aj as PlayImportPolicy, ak as PlayPackageImport, al as PlayRuntimeFeature } from '../compiler-manifest-BaJfE-5H.js';
 import '@sinclair/typebox';
 
 type ImportedPlayDependency = {

package/dist/release.d.mts

@@ -0,0 +1,255 @@
+/// <reference path="./text-imports.d.ts" />
+/**
+ * Single source of truth for SDK release metadata.
+ *
+ * Ordinary SDK PRs do NOT bump `version` here. Patch version selection
+ * happens at publish time: on push to main, `.github/workflows/sdk-release.yml`
+ * (via `scripts/sdk-release-autobump.ts`) compares the built package against
+ * the latest published npm tarball and, when the content changed, stamps the
+ * next unpublished patch into `version` in the CI workspace only and
+ * publishes it in the same run. That patch stamp is not
+ * committed back to main; production endpoints read npm metadata when they
+ * need the newest patch-level SDK/CLI version.
+ *
+ * Edit THIS file by hand only for deliberate release decisions:
+ *   - minor/major version bumps (set `version`),
+ *   - API-major cutovers (set `contracts.api.currentMajor`; leave `version` to the
+ *     publish-time patch selector),
+ *   - support-window moves (`minimumSupported` / `deprecatedBelow`).
+ * The automation never touches API compatibility policy, `minimumSupported`, or
+ * `deprecatedBelow`.
+ *
+ * Everything else derives from these values:
+ *
+ *   - `packages/sdk/src/version.ts` re-exports `SDK_VERSION` and `SDK_API_CONTRACT`.
+ *   - `apps/deepline-api/src/lib/sdk/release-policy.ts` re-exports `SDK_RELEASE_POLICY`.
+ *   - `packages/sdk/package.json` `version` is stamped from `SDK_RELEASE.version` by
+ *     `scripts/sync-sdk-package-version.ts`, which runs as part of
+ *     `bun run sdk:build`.
+ *   - `contracts/sdk-api.manifest.json` is regenerated at build time from
+ *     `apps/deepline-api/src/lib/sdk/api-routes.ts` and the apiContract here; the matching
+ *     `contracts/sdk-api.manifest.hash` is an ignored local/CI audit artifact.
+ *
+ * Any drift between release source and derived release locations is a
+ * `check:sdk-release-readiness` failure with a one-shot fix command; SDK/API
+ * compatibility policy is enforced by `bun run sdk:api-contract:check`.
+ */
+type SdkReleaseChannel = 'latest' | 'next' | 'beta';
+/**
+ * The named public protocols. These are intentionally independent:
+ *
+ * - `api` is the HTTP SDK/CLI protocol. It is additive within a major.
+ * - `playArtifact` is the immutable client-bundled Play payload ABI.
+ * - `release` controls promotion/publishing; it is not a client protocol.
+ *
+ * Do not use an SDK package version or a date string as an artifact ABI.
+ */
+type DeeplineContractPolicy = {
+    api: {
+        name: 'sdk-http-api';
+        currentMajor: number;
+        supportedMajors: readonly number[];
+        /** Transitional value for installed SDKs that only send the old header. */
+        legacyWireIds: readonly string[];
+    };
+    playArtifact: {
+        name: 'play-artifact-runtime';
+        currentVersion: number;
+        supportedVersions: readonly number[];
+    };
+    release: {
+        name: 'production-sdk-release';
+        /** npm may publish only from the active, healthy Production SHA. */
+        publishFrom: 'latest-successful-production-deployment';
+        /** A newer merge cancels an in-flight decision; reconciliation picks the last healthy SHA. */
+        coalesce: 'latest-healthy';
+    };
+};
+type SdkSupportPolicy = {
+    /**
+     * Anything strictly below this returns `status: "unsupported"` from
+     * `/api/v2/sdk/compat` and the CLI must hard-fail with the update command.
+     * Only advance after the support window closes.
+     */
+    minimumSupported: string;
+    /**
+     * Anything strictly below this returns `status: "deprecated"` (still works,
+     * warns). Advance when a release becomes the new floor.
+     */
+    deprecatedBelow: string;
+    /**
+     * Command-scoped support floors for SDK CLI workflows whose local behavior
+     * can break while the network API contract remains compatible.
+     */
+    commandMinimumSupported?: ReadonlyArray<{
+        command: string;
+        displayCommand?: string;
+        minimumSupported: string;
+        reason: string;
+    }>;
+    /**
+     * The version that first shipped a command.
+     *
+     * Deliberately not a support floor. `commandMinimumSupported` says an older
+     * client is BROKEN for a command and forces an update; this says only that
+     * an older client never had the command at all. That difference matters in
+     * both directions: introducing a command must not independently require an
+     * update, and a support floor may not exceed the version being released,
+     * while an introduction version is a fact about an already-published
+     * release. The general default-on freshness policy may still update an older
+     * installed CLI.
+     *
+     * It exists because agent skills are served by the backend and re-synced on
+     * nearly every CLI invocation, while the CLI stays pinned. A release that
+     * adds a command and documents it in the same commit therefore hands every
+     * installed client instructions it cannot follow, and `unknown command` is
+     * all the author sees. Recording the version lets the CLI say which release
+     * added it. `check:skill-cli-commands` requires an entry here before a skill
+     * may document a command.
+     */
+    commandIntroducedIn?: ReadonlyArray<{
+        command: string;
+        introducedIn: string;
+        reason: string;
+    }>;
+    /** Previously published wire contracts that remain supported. */
+    compatibleApiContracts?: readonly string[];
+    /**
+     * Published package versions that must keep working for direct SDK tool
+     * callers. CI installs each package from npm and exercises `tools.get` and
+     * `tools.execute` without involving the CLI or Play runtime.
+     */
+    directToolsCompatibilityVersions?: readonly string[];
+    /**
+     * Diagnostic freshness threshold reported by `/api/v2/sdk/compat`.
+     * Ownership-aware installed CLIs auto-update when older; this value remains
+     * metadata for clients and operational diagnostics.
+     */
+    autoUpdatePatchLag?: number;
+};
+type SdkRelease = {
+    /**
+     * Version published to npm. Usually stamped by the release workflow at
+     * publish time (auto-bump); edit by hand only for minor/major releases.
+     */
+    version: string;
+    /**
+     * One concise, agent-readable explanation shown while this release is an
+     * available update. Keep it actionable; the compatibility route includes it
+     * in its existing update message so older installed CLIs can print it too.
+     */
+    updateSummary?: string;
+    /** Capabilities stamped into the published package's `deepline` metadata. */
+    packageCapabilities: {
+        updatePreferences: 1;
+    };
+    /** Named compatibility policies. This is the only authored contract policy. */
+    contracts: DeeplineContractPolicy;
+    /** Public support policy reported by `/api/v2/sdk/compat`. */
+    supportPolicy: SdkSupportPolicy;
+};
+declare const SDK_RELEASE: {
+    readonly version: "0.3.90";
+    readonly updateSummary: "Play grep now uses one source-only Convex full-text index. It no longer scans the registry, pages through the complete indexed match set, and rejects retired grep modes. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.";
+    readonly packageCapabilities: {
+        readonly updatePreferences: 1;
+    };
+    readonly contracts: {
+        readonly api: {
+            readonly name: "sdk-http-api";
+            readonly currentMajor: 3;
+            readonly supportedMajors: readonly [3, 2];
+            readonly legacyWireIds: readonly ["2026-09-play-grep-convex-index-hard-cutover", "2026-07-admin-cli-local-cutover", "2026-07-native-monitor-launch-hard-cutover"];
+        };
+        readonly playArtifact: {
+            readonly name: "play-artifact-runtime";
+            readonly currentVersion: 2;
+            readonly supportedVersions: readonly [1, 2];
+        };
+        readonly release: {
+            readonly name: "production-sdk-release";
+            readonly publishFrom: "latest-successful-production-deployment";
+            readonly coalesce: "latest-healthy";
+        };
+    };
+    readonly supportPolicy: {
+        readonly minimumSupported: "0.1.53";
+        readonly deprecatedBelow: "0.3.1";
+        readonly commandIntroducedIn: readonly [{
+            readonly command: "notifications";
+            readonly introducedIn: "0.2.40";
+            readonly reason: "deepline notifications was added in SDK CLI 0.2.40. Older versions have no way to configure a Play failure alert, so a cron Play that dies reports to nobody.";
+        }];
+        readonly commandMinimumSupported: readonly [{
+            readonly command: "enrich";
+            readonly minimumSupported: "0.1.238";
+            readonly reason: "Older SDK CLI enrich generated stale play source; SDK CLI enrich 0.1.153 generated removed StepOptions fields in play source; SDK CLI enrich before 0.1.175 could silently succeed on the empty-waterfall bug when a requested waterfall returned no values for selected rows; SDK CLI enrich before 0.1.230 could convert extractor failures into successful unmatched results; SDK CLI enrich before 0.1.238 could drop a nested provider email match during generic pick(\"email\") extraction and materialize it as NO_MATCH.";
+        }, {
+            readonly command: "plays";
+            readonly minimumSupported: "0.1.241";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract. Update before checking, publishing, or running plays.";
+        }, {
+            readonly command: "plays run";
+            readonly minimumSupported: "0.1.253";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract; versions before 0.1.253 open the play page by default and accept the removed --no-open flag.";
+        }, {
+            readonly command: "run";
+            readonly displayCommand: "plays run";
+            readonly minimumSupported: "0.1.253";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract; versions before 0.1.253 open the play page by default and accept the removed --no-open flag.";
+        }, {
+            readonly command: "plays check";
+            readonly minimumSupported: "0.1.241";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play authoring and validate against the retired esm_workers artifact contract.";
+        }, {
+            readonly command: "check";
+            readonly displayCommand: "plays check";
+            readonly minimumSupported: "0.1.241";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play authoring and validate against the retired esm_workers artifact contract.";
+        }, {
+            readonly command: "plays publish";
+            readonly minimumSupported: "0.1.241";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.";
+        }, {
+            readonly command: "publish";
+            readonly displayCommand: "plays publish";
+            readonly minimumSupported: "0.1.241";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.";
+        }, {
+            readonly command: "plays set-live";
+            readonly minimumSupported: "0.1.241";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.";
+        }, {
+            readonly command: "set-live";
+            readonly displayCommand: "plays set-live";
+            readonly minimumSupported: "0.1.241";
+            readonly reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.";
+        }, {
+            readonly command: "runs";
+            readonly minimumSupported: "0.1.111";
+            readonly reason: "Run result rows now render as dataset handles with explicit export commands.";
+        }, {
+            readonly command: "runs get";
+            readonly minimumSupported: "0.1.111";
+            readonly reason: "Run result rows now render as dataset handles with explicit export commands.";
+        }, {
+            readonly command: "get";
+            readonly displayCommand: "runs get";
+            readonly minimumSupported: "0.1.111";
+            readonly reason: "Run result rows now render as dataset handles with explicit export commands.";
+        }, {
+            readonly command: "runs export";
+            readonly minimumSupported: "0.1.111";
+            readonly reason: "Run result row datasets now use the dataset-handle export contract.";
+        }, {
+            readonly command: "export";
+            readonly displayCommand: "runs export";
+            readonly minimumSupported: "0.1.111";
+            readonly reason: "Run result row datasets now use the dataset-handle export contract.";
+        }];
+        readonly directToolsCompatibilityVersions: readonly ["0.1.171"];
+        readonly autoUpdatePatchLag: 2;
+    };
+};
+
+export { type DeeplineContractPolicy, SDK_RELEASE, type SdkRelease, type SdkReleaseChannel, type SdkSupportPolicy };