deepline 0.1.220 → 0.1.222

package/dist/cli/index.js

@@ -625,10 +625,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.220",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.220",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -5350,6 +5350,12 @@ function printCommandEnvelope(envelope, options = {}) {
 }
 
 // src/cli/commands/admin.ts
+function laneStatusLine(input2) {
+  if (input2.lane) {
+    return `status: ${input2.lane.status}${input2.lane.active ? " (active)" : ""}`;
+  }
+  return input2.registration ? `status: ${input2.registration.status}` : "status: (not in registry)";
+}
 function normalizeEnvironment(value) {
   const trimmed = value?.trim().toLowerCase();
   if (!trimmed || trimmed === "production" || trimmed === "prod") {
@@ -5402,7 +5408,7 @@ async function handleLanesShow(releaseId, options) {
             title: `Lane ${releaseId} (${environment}):`,
             lines: [
               `registered: ${payload.registered}`,
-              payload.lane ? `status: ${payload.lane.status}${payload.lane.active ? " (active)" : ""}` : "status: (not in registry)",
+              laneStatusLine(payload),
               `queue: ${payload.retireCheck.queue}`,
               `queued tasks: ${payload.retireCheck.queuedTasks}`,
               `non-terminal runs: ${payload.retireCheck.nonTerminalRuns}`,
@@ -5444,7 +5450,7 @@ async function handleReleasesActivate(releaseId, options) {
     {
       releaseId,
       environment,
-      ...options.schedulerBackend ? { schedulerBackend: options.schedulerBackend } : {}
+      schedulerBackend: options.schedulerBackend ?? "absurd"
     }
   );
   printCommandEnvelope(
@@ -5469,7 +5475,10 @@ function registerAdminCommands(program) {
   lanes.command("show <releaseId>").description("Show one lane and its retire-gate depth.").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesShow);
   lanes.command("retire-check <releaseId>").description("Check whether a lane is safe to retire (queue empty).").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesRetireCheck);
   const releases = admin.command("releases").description("Manage the active runtime release pointer.");
-  releases.command("activate <releaseId>").description("Flip the active runtime release to a prior registered lane.").option("--environment <env>", "production (default) or preview").option("--scheduler-backend <backend>", "absurd or workers_edge").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
+  releases.command("activate <releaseId>").description("Activate a prior registered Absurd release lane.").option("--environment <env>", "production (default) or preview").option(
+    "--scheduler-backend <backend>",
+    "compatibility flag: absurd only; workers_edge is disabled"
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
 }
 
 // src/cli/commands/auth.ts
@@ -14648,6 +14657,73 @@ function parsePlayCheckOptions(args) {
   const jsonOutput = argsWantJson(args);
   return { target, jsonOutput };
 }
+function parsePlayPublishOptions(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error(
+      "Usage: deepline plays publish <play-file.ts|play-name> [--expected-artifact <hash>] [--dry-run] [--latest|--revision-id <id>] [--json]"
+    );
+  }
+  let revisionId;
+  let useLatest = false;
+  let expectedArtifactHash;
+  let dryRun = false;
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--revision-id") {
+      revisionId = args[++index];
+      if (!revisionId) throw new Error("--revision-id requires a revision id.");
+      continue;
+    }
+    if (arg === "--latest") {
+      useLatest = true;
+      continue;
+    }
+    if (arg === "--expected-artifact") {
+      expectedArtifactHash = args[++index];
+      if (!expectedArtifactHash) {
+        throw new Error("--expected-artifact requires an artifact hash.");
+      }
+      continue;
+    }
+    if (arg.startsWith("--expected-artifact=")) {
+      expectedArtifactHash = arg.slice("--expected-artifact=".length);
+      if (!expectedArtifactHash) {
+        throw new Error("--expected-artifact requires an artifact hash.");
+      }
+      continue;
+    }
+    if (arg === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (arg === "--json") continue;
+    throw new Error(`Unknown plays publish option: ${arg}`);
+  }
+  if (revisionId && useLatest) {
+    throw new Error("Choose only one live target: --latest or --revision-id.");
+  }
+  return {
+    target,
+    revisionId,
+    useLatest,
+    expectedArtifactHash,
+    dryRun,
+    jsonOutput: argsWantJson(args)
+  };
+}
+function formatByteBudget(usedBytes, limitBytes) {
+  return `${usedBytes.toLocaleString()} B / ${limitBytes.toLocaleString()} B`;
+}
+function printPlayCheckLimits(limits) {
+  if (!limits) return;
+  console.log(
+    `  revision storage: ${formatByteBudget(limits.revisionStorage.usedBytes, limits.revisionStorage.limitBytes)}`
+  );
+  console.log(
+    `  bundle: ${formatByteBudget(limits.bundle.usedBytes, limits.bundle.limitBytes)}`
+  );
+}
 function shouldUseLocalOnlyPlayCheck() {
   const value = process.env.DEEPLINE_PLAY_CHECK_LOCAL_ONLY?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
@@ -14960,7 +15036,11 @@ async function handlePlayCheck(args) {
       );
     } else {
       console.log(`\u2713 ${playName} passed local play check`);
+      console.log(`  source: ${graph.root.artifact.sourceHash.slice(0, 12)}`);
       console.log(`  artifact: ${result2.artifactHash.slice(0, 12)}`);
+      console.log(
+        `  publish: deepline plays publish ${shellQuote2(options.target)} --expected-artifact ${result2.artifactHash}`
+      );
       printToolGetterHints(result2.toolGetterHints);
     }
     return 0;
@@ -15002,6 +15082,15 @@ async function handlePlayCheck(args) {
     if (enrichedResult.artifactHash) {
       console.log(`  artifact: ${enrichedResult.artifactHash.slice(0, 12)}`);
     }
+    if (enrichedResult.sourceHash) {
+      console.log(`  source: ${enrichedResult.sourceHash.slice(0, 12)}`);
+    }
+    printPlayCheckLimits(enrichedResult.limits);
+    if (enrichedResult.artifactHash) {
+      console.log(
+        `  publish: deepline plays publish ${shellQuote2(options.target)} --expected-artifact ${enrichedResult.artifactHash}`
+      );
+    }
     printPlayTriggers(enrichedResult.triggers);
     printRecognizedSummary(enrichedResult.recognized);
     printPlayCheckIssues(enrichedResult.issues, (line) => console.log(line));
@@ -16358,28 +16447,15 @@ async function handlePlayDescribe(args) {
   return 0;
 }
 async function handlePlayPublish(args) {
-  const playName = args[0];
-  if (!playName) {
-    console.error(
-      "Usage: deepline plays publish <play-file.ts|play-name> [--latest|--revision-id <id>] [--json]"
-    );
-    return 1;
-  }
-  let revisionId;
-  let useLatest = false;
-  for (let index = 1; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--revision-id" && args[index + 1]) {
-      revisionId = args[++index];
-    }
-    if (arg === "--latest") {
-      useLatest = true;
-    }
-  }
-  if (revisionId && useLatest) {
-    console.error("Choose only one live target: --latest or --revision-id.");
-    return 1;
+  let options;
+  try {
+    options = parsePlayPublishOptions(args);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
   }
+  const { target: playName, useLatest } = options;
+  let revisionId = options.revisionId;
   const client2 = new DeeplineClient();
   if (isFileTarget(playName)) {
     if (revisionId || useLatest) {
@@ -16396,6 +16472,66 @@ async function handlePlayPublish(args) {
         () => collectBundledPlayGraph((0, import_node_path11.resolve)(playName))
       );
       assertBundledPlayGraphDescriptions(graph);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+    const rootPlayName = graph.root.playName ?? extractPlayName(graph.root.sourceCode, graph.root.filePath);
+    const artifactHash = graph.root.artifact.artifactHash;
+    if (options.expectedArtifactHash && options.expectedArtifactHash !== artifactHash) {
+      const result3 = {
+        ok: false,
+        code: "PLAY_ARTIFACT_HASH_MISMATCH",
+        message: "Refusing to publish: the local file no longer produces the artifact checked earlier.",
+        expectedArtifactHash: options.expectedArtifactHash,
+        currentArtifactHash: artifactHash,
+        next: `deepline plays check ${shellQuote2(playName)}`
+      };
+      if (options.jsonOutput) {
+        process.stdout.write(`${JSON.stringify(result3)}
+`);
+      } else {
+        console.error(result3.message);
+        console.error(`  checked artifact: ${result3.expectedArtifactHash}`);
+        console.error(`  current artifact: ${result3.currentArtifactHash}`);
+        console.error(`  run: ${result3.next}`);
+      }
+      return 7;
+    }
+    const dryRun = {
+      ok: true,
+      dryRun: true,
+      name: rootPlayName,
+      sourcePath: graph.root.filePath,
+      sourceHash: graph.root.artifact.sourceHash,
+      artifactHash,
+      graphHash: graph.root.artifact.graphHash,
+      importedPlayCount: Math.max(0, graph.nodes.size - 1),
+      plannedMutation: "register revision and promote it live",
+      expectedArtifactHash: options.expectedArtifactHash ?? null
+    };
+    if (options.dryRun) {
+      if (options.jsonOutput) {
+        process.stdout.write(`${JSON.stringify(dryRun)}
+`);
+      } else {
+        console.log(`Dry run: ${rootPlayName}`);
+        console.log(`  source: ${dryRun.sourceHash}`);
+        console.log(`  artifact: ${dryRun.artifactHash}`);
+        console.log(`  would: ${dryRun.plannedMutation}`);
+      }
+      return 0;
+    }
+    let previousLive = null;
+    try {
+      previousLive = (await client2.getPlay(rootPlayName)).play.liveRevision ?? null;
+    } catch (error) {
+      if (!(error instanceof DeeplineError) || error.statusCode !== 404) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 5;
+      }
+    }
+    try {
       await traceCliSpan(
         "cli.play_publish_compile_manifests",
         { targetKind: "file", nodeCount: graph.nodes.size },
@@ -16410,13 +16546,12 @@ async function handlePlayPublish(args) {
       console.error(error instanceof Error ? error.message : String(error));
       return 1;
     }
-    const rootPlayName = graph.root.playName ?? extractPlayName(graph.root.sourceCode, graph.root.filePath);
     const published = await traceCliSpan(
       "cli.play_publish_register_root",
       {
         targetKind: "file",
         playName: rootPlayName,
-        artifactHash: graph.root.artifact.artifactHash
+        artifactHash
       },
       () => client2.registerPlayArtifact({
         name: rootPlayName,
@@ -16428,17 +16563,63 @@ async function handlePlayPublish(args) {
         publish: true
       })
     );
-    process.stdout.write(
-      `${JSON.stringify({
-        success: true,
-        name: rootPlayName,
-        liveVersion: published.version ?? null,
-        revisionId: published.revisionId ?? null,
-        triggerMetadata: published.triggerMetadata ?? null,
-        triggerBindings: published.triggerBindings ?? []
-      })}
-`
-    );
+    const result2 = {
+      success: true,
+      name: rootPlayName,
+      sourcePath: graph.root.filePath,
+      sourceHash: graph.root.artifact.sourceHash,
+      artifactHash,
+      liveVersion: published.version ?? null,
+      revisionId: published.revisionId ?? null,
+      previousLiveVersion: previousLive?.version ?? null,
+      previousArtifactHash: previousLive?.artifactHash ?? null,
+      sourceBytes: {
+        before: previousLive?.sourceCode ? Buffer.byteLength(previousLive.sourceCode, "utf8") : null,
+        after: Buffer.byteLength(graph.root.sourceCode, "utf8")
+      },
+      triggerMetadata: published.triggerMetadata ?? null,
+      triggerBindings: published.triggerBindings ?? []
+    };
+    if (options.jsonOutput) {
+      process.stdout.write(`${JSON.stringify(result2)}
+`);
+    } else {
+      console.log(
+        `\u2713 Published ${rootPlayName} as v${result2.liveVersion ?? "?"}`
+      );
+      console.log(`  source: ${result2.sourceHash.slice(0, 12)}`);
+      console.log(`  artifact: ${result2.artifactHash.slice(0, 12)}`);
+      if (result2.previousLiveVersion !== null) {
+        console.log(
+          `  previous live: v${result2.previousLiveVersion} (${result2.previousArtifactHash?.slice(0, 12) ?? "unknown artifact"})`
+        );
+      }
+      if (result2.sourceBytes.before !== null) {
+        console.log(
+          `  source bytes: ${result2.sourceBytes.before.toLocaleString()} \u2192 ${result2.sourceBytes.after.toLocaleString()}`
+        );
+      }
+      console.log(
+        `  revisions: deepline plays versions --name ${rootPlayName}`
+      );
+    }
+    return 0;
+  }
+  if (options.expectedArtifactHash) {
+    console.error("--expected-artifact only applies to a local play file.");
+    return 2;
+  }
+  if (options.dryRun) {
+    const result2 = {
+      ok: true,
+      dryRun: true,
+      name: playName,
+      plannedMutation: "promote a saved revision live",
+      revisionId: revisionId ?? null,
+      latest: useLatest
+    };
+    process.stdout.write(`${JSON.stringify(result2)}
+`);
     return 0;
   }
   const resolvedName = parseReferencedPlayTarget2(playName).playName;
@@ -16802,7 +16983,9 @@ Notes:
   Mutates cloud state. For a saved play, --latest or --revision-id promotes an
   existing saved revision live.
   Local .play.ts publishing bundles the file, validates it, saves a revision,
-  and promotes that revision live.
+  and promotes that revision live. Use --expected-artifact with the hash from
+  plays check to refuse publishing bytes that changed after validation.
+  --dry-run bundles only and prints the exact artifact that would be published.
   Running a local file with plays run does not publish it.
 
 Examples:
@@ -16810,27 +16993,40 @@ Examples:
   deepline plays set-live my-play --revision-id <revision-id> --json
   deepline plays set-live my.play.ts --json
   deepline plays publish my.play.ts --json
+  deepline plays check my.play.ts
+  deepline plays publish my.play.ts --expected-artifact <artifact-hash>
+  deepline plays publish my.play.ts --dry-run --json
 `
   );
   addPublishHelp(
     play.command("publish <target>").description(
       "Promote a saved play revision or publish a local play file."
     )
-  ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
+  ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option(
+    "--expected-artifact <hash>",
+    "Require the local file to produce this checked artifact hash"
+  ).option("--dry-run", "Bundle and show the planned publish without mutation").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
       target,
       ...options.latest ? ["--latest"] : [],
       ...options.revisionId ? ["--revision-id", options.revisionId] : [],
+      ...options.expectedArtifact ? ["--expected-artifact", options.expectedArtifact] : [],
+      ...options.dryRun ? ["--dry-run"] : [],
       ...options.json ? ["--json"] : []
     ]);
   });
   addPublishHelp(
     play.command("set-live <target>").description("Promote a saved revision or publish a local play file.")
-  ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
+  ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option(
+    "--expected-artifact <hash>",
+    "Require the local file to produce this checked artifact hash"
+  ).option("--dry-run", "Bundle and show the planned publish without mutation").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
       target,
       ...options.latest ? ["--latest"] : [],
       ...options.revisionId ? ["--revision-id", options.revisionId] : [],
+      ...options.expectedArtifact ? ["--expected-artifact", options.expectedArtifact] : [],
+      ...options.dryRun ? ["--dry-run"] : [],
       ...options.json ? ["--json"] : []
     ]);
   });