@cimplify/cli 0.15.3 → 0.16.0

package/dist/{chunk-MLE4MVYC.mjs → chunk-TT4YI33G.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { CliError, CLI_ERROR_CODE } from './chunk-3QUK5BPY.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
 import { promises } from 'fs';
 import os from 'os';
 import path from 'path';
@@ -137,4 +137,4 @@ ${STATE_GITIGNORE_LINE}
   await promises.writeFile(gitignore, next, ENCODING_UTF8);
 }
 
-export { clearAuth, clearProjectLink, readAuth, readAuthOrNull, readProjectLink, readProjectLinkOrNull, readProjectState, writeAuth, writeProjectLink, writeProjectState, writeStepUp };
+export { authConfigDir, clearAuth, clearProjectLink, readAuth, readAuthOrNull, readProjectLink, readProjectLinkOrNull, readProjectState, writeAuth, writeProjectLink, writeProjectState, writeStepUp };

package/dist/chunk-TYV2SVFN.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { SessionError, CaptureSession, FRAME_MS, DEFAULT_EPOCH_MS } from './chunk-KNPYBZ6B.mjs';
+import { buildLocal, workPath } from './chunk-CPBESPWK.mjs';
+import { writeLoopProfile, LOOP_PROFILE_FILE } from './chunk-5HP2INMY.mjs';
+import { locateToolchain } from './chunk-ZUCDXRFI.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { createHash } from 'crypto';
+import { promises } from 'fs';
+import path from 'path';
+
+var CAPTURE_SCHEMA = "cimplify.capture/1";
+var FINAL_CAPTURE = "final";
+async function prepareSession(root) {
+  const toolchain = locateToolchain(root);
+  if (toolchain === null) throw new SessionError("the pinned SDK is not installed, so the game cannot be served; run your package manager's install");
+  const build = await buildLocal(root, { uiSites: true, loops: { probe: true } });
+  const errors = build.result.diagnostics.filter((d) => d.severity === "error");
+  if (errors.length > 0) throw new SessionError(`the build failed:
+${errors.map(formatDiagnostic).join("\n")}`);
+  return { root, build, toolchain };
+}
+function digest(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+async function runSession(setup, request) {
+  const session = await CaptureSession.open(setup, { device: request.device, backend: request.backend, seed: request.seed, scene: request.scene });
+  const out = [];
+  const take = async (name) => {
+    const png = request.screenshots || request.inspect ? await session.screenshot() : new Uint8Array(0);
+    const inspection = request.inspect ? await session.inspect(png) : null;
+    const snapshot = inspection === null ? await session.snapshot() : null;
+    const report = inspection?.report ?? null;
+    const readiness = await session.readiness();
+    const device = request.device;
+    out.push({
+      png,
+      inspect: report,
+      sidecar: {
+        schema: CAPTURE_SCHEMA,
+        name,
+        png: "",
+        sha256: png.length === 0 ? "" : digest(png),
+        frame: session.frame,
+        time_ms: Math.round(session.frame * FRAME_MS * 1e3) / 1e3,
+        seed: request.seed,
+        epoch_ms: DEFAULT_EPOCH_MS,
+        device: { name: device.name, width: device.width, height: device.height, scale: device.scale, insets: device.insets },
+        backend: request.backend,
+        css_safe_area: session.cssSafeArea,
+        scene: report?.scene ?? snapshot?.scene ?? { requested: request.scene, applied: null, current: null },
+        script: request.scriptPath,
+        ui: report === null ? null : { nodes: report.nodes.length, findings: report.checks.findings.length },
+        readiness
+      }
+    });
+  };
+  try {
+    if (request.script !== null) await session.run(request.script, take);
+    await session.advanceTo(request.frame);
+    await take(FINAL_CAPTURE);
+    await recordLoopProfile(setup.root, session);
+    return out;
+  } finally {
+    await session.close();
+  }
+}
+async function recordLoopProfile(root, session) {
+  const samples = await session.loopSamples();
+  const keys = Object.keys(samples);
+  if (keys.length === 0 || session.frame <= 0) return null;
+  const loops = {};
+  for (const key of keys) {
+    const [ms, calls, rows] = samples[key];
+    loops[key] = { ms, calls, rows };
+  }
+  return writeLoopProfile(workPath(root, LOOP_PROFILE_FILE), session.frame, loops);
+}
+async function writeCapture(frame, pngPath) {
+  await promises.mkdir(path.dirname(pngPath), { recursive: true });
+  await promises.writeFile(pngPath, frame.png);
+  const sidecar = { ...frame.sidecar, png: path.basename(pngPath) };
+  await promises.writeFile(`${pngPath.slice(0, -path.extname(pngPath).length)}.json`, `${JSON.stringify({ ...sidecar, inspect: frame.inspect }, null, 2)}
+`);
+  return sidecar;
+}
+function framesFor(time, frame, fallback) {
+  if (time !== void 0 && frame !== void 0) return "pass --frame or --time, not both";
+  if (frame !== void 0) {
+    const n = Number(frame);
+    return Number.isInteger(n) && n >= 0 ? n : `--frame takes a whole number; got "${frame}"`;
+  }
+  if (time !== void 0) {
+    const match = /^(\d+(?:\.\d+)?)(ms|s)?$/.exec(time);
+    if (match === null) return `--time takes seconds or milliseconds, such as 2.5s or 2500ms; got "${time}"`;
+    const ms = Number(match[1]) * (match[2] === "ms" ? 1 : 1e3);
+    return Math.round(ms / FRAME_MS);
+  }
+  return fallback;
+}
+
+export { CAPTURE_SCHEMA, FINAL_CAPTURE, framesFor, prepareSession, runSession, writeCapture };

package/dist/chunk-VHK7WBO3.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+import { diagnostic } from './chunk-SGT5IJVW.mjs';
+import ts from 'typescript';
+
+var SCENES_FLAG = "CIMPLIFY_GENERATIVE_SCENES";
+var SCENE_MODULES = ["@cimplify/sdk/game", "@cimplify/sdk"];
+var SCENE_FUNCTION = "scene";
+var SITE_HINT = /\bscene\s*\(/;
+var NOT_STATIC = "scene.not_static";
+function scenesEnabled(env = process.env) {
+  const v = env[SCENES_FLAG];
+  return v !== "0" && v !== "false";
+}
+async function sceneCompilerFromFlag(env = process.env) {
+  if (!scenesEnabled(env)) return null;
+  const sdk = await import('@cimplify/sdk/game');
+  return (def) => sdk.compileScene(def);
+}
+function mentionsScenes(text) {
+  return SCENE_MODULES.some((m) => text.includes(m)) && SITE_HINT.test(text);
+}
+var NotStatic = class {
+  constructor(node) {
+    this.node = node;
+  }
+  node;
+};
+function unwrap(expr) {
+  let e = expr;
+  while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isSatisfiesExpression(e) || ts.isNonNullExpression(e) || ts.isTypeAssertionExpression(e)) e = e.expression;
+  return e;
+}
+function keyOf(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)) return name.text;
+  return null;
+}
+function evaluate(node) {
+  const e = unwrap(node);
+  if (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e)) return e.text;
+  if (ts.isNumericLiteral(e)) return Number(e.text);
+  if (e.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (e.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (e.kind === ts.SyntaxKind.NullKeyword) return null;
+  if (ts.isPrefixUnaryExpression(e) && e.operator === ts.SyntaxKind.MinusToken) {
+    const v = evaluate(e.operand);
+    if (typeof v === "number") return -v;
+    throw new NotStatic(e);
+  }
+  if (ts.isArrayLiteralExpression(e)) return e.elements.map((x) => ts.isSpreadElement(x) ? fail(x) : evaluate(x));
+  if (ts.isObjectLiteralExpression(e)) {
+    const out = {};
+    for (const p of e.properties) {
+      if (!ts.isPropertyAssignment(p)) throw new NotStatic(p);
+      const key = keyOf(p.name);
+      if (key === null) throw new NotStatic(p.name);
+      out[key] = evaluate(p.initializer);
+    }
+    return out;
+  }
+  throw new NotStatic(e);
+}
+function fail(node) {
+  throw new NotStatic(node);
+}
+function sceneImports(sf) {
+  const names = /* @__PURE__ */ new Set();
+  for (const stmt of sf.statements) {
+    if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier) || !SCENE_MODULES.includes(stmt.moduleSpecifier.text)) continue;
+    const bindings = stmt.importClause?.namedBindings;
+    if (bindings === void 0 || !ts.isNamedImports(bindings)) continue;
+    for (const el of bindings.elements) {
+      if ((el.propertyName ?? el.name).text === SCENE_FUNCTION) names.add(el.name.text);
+    }
+  }
+  return names;
+}
+function property(obj, key) {
+  for (const p of obj.properties) if (ts.isPropertyAssignment(p) && keyOf(p.name) === key) return p;
+  return null;
+}
+function bindingOf(call) {
+  const parent = call.parent;
+  return ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name) ? parent.name.text : null;
+}
+function position(sf, node) {
+  const at = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+  return { line: at.line + 1, column: at.character + 1 };
+}
+function findSceneSites(path, text) {
+  const sf = ts.createSourceFile(path, text, ts.ScriptTarget.ES2022, true, ts.ScriptKind.TS);
+  const callees = sceneImports(sf);
+  const sites = [];
+  const diagnostics = [];
+  if (callees.size === 0) return { sites, diagnostics };
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && callees.has(node.expression.text)) {
+      const [nameArg, specArg] = node.arguments;
+      const objects = /* @__PURE__ */ new Map();
+      const fields = /* @__PURE__ */ new Map();
+      const spec = specArg === void 0 ? null : unwrap(specArg);
+      if (spec !== null && ts.isObjectLiteralExpression(spec)) {
+        const objectsProp = property(spec, "objects");
+        if (objectsProp !== null && ts.isObjectLiteralExpression(unwrap(objectsProp.initializer))) {
+          for (const p of unwrap(objectsProp.initializer).properties) {
+            if (!ts.isPropertyAssignment(p)) continue;
+            const key = keyOf(p.name);
+            if (key === null) continue;
+            objects.set(key, p);
+            const body = unwrap(p.initializer);
+            if (!ts.isObjectLiteralExpression(body)) continue;
+            for (const f of body.properties) {
+              const fk = ts.isPropertyAssignment(f) ? keyOf(f.name) : null;
+              if (fk !== null && ts.isPropertyAssignment(f)) fields.set(`${key}.${fk}`, f);
+            }
+          }
+        }
+        for (const top of ["area", "seed", "quality", "style", "agent"]) {
+          const p = property(spec, top);
+          if (p !== null) fields.set(top, p);
+        }
+      }
+      let definition = null;
+      const label = nameArg !== void 0 && (ts.isStringLiteral(nameArg) || ts.isNoSubstitutionTemplateLiteral(nameArg)) ? nameArg.text : bindingOf(node) ?? "scene";
+      try {
+        if (nameArg === void 0 || specArg === void 0) throw new NotStatic(node);
+        const name = evaluate(nameArg);
+        if (typeof name !== "string") throw new NotStatic(nameArg);
+        definition = { kind: "scene", name, spec: evaluate(specArg) };
+      } catch (error) {
+        if (!(error instanceof NotStatic)) throw error;
+        diagnostics.push({
+          code: NOT_STATIC,
+          severity: "error",
+          message: "scene arguments must be literal (strings, numbers, booleans, arrays and objects) so the build can check them",
+          object: null,
+          field: null,
+          fix: "inline the value instead of computing it",
+          path,
+          scene: label,
+          ...position(sf, error.node)
+        });
+      }
+      sites.push({ path, binding: bindingOf(node), definition, call: node, objects, fields, source: sf });
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return { sites, diagnostics };
+}
+function locate(site, d) {
+  const fieldNode = d.object !== null && d.field !== null ? site.fields.get(`${d.object}.${d.field}`) : d.field !== null ? site.fields.get(d.field.split(".")[0]) : void 0;
+  const objectNode = d.object !== null ? site.objects.get(d.object) : void 0;
+  const node = fieldNode ?? objectNode ?? site.call;
+  return { ...d, path: site.path, scene: site.definition?.name ?? site.binding ?? "scene", ...position(site.source, node) };
+}
+function compileSites(path, text, compile) {
+  const found = findSceneSites(path, text);
+  const diagnostics = [...found.diagnostics];
+  const compiled = found.sites.map((site) => {
+    if (site.definition === null) return null;
+    const result = compile(site.definition);
+    for (const d of result.diagnostics) diagnostics.push(locate(site, d));
+    return result;
+  });
+  return { sites: found.sites, compiled, diagnostics };
+}
+function formatSceneDiagnostic(d) {
+  const who = d.object === null ? `scene ${d.scene}` : `${d.scene}.${d.object}`;
+  const fix = d.fix === null ? "" : ` (fix: ${d.fix})`;
+  return `${d.path}:${d.line}:${d.column}: ${d.severity} ${d.code}: ${who}: ${d.message}${fix}`;
+}
+function toBuildDiagnostic(d) {
+  const who = d.object === null ? `scene ${d.scene}` : `${d.scene}.${d.object}`;
+  const fix = d.fix === null ? "" : `; fix: ${d.fix}`;
+  return diagnostic(d.code, `${who}: ${d.message}${fix}`, d.path, { line: d.line, column: d.column }, d.severity);
+}
+function buildScenes(files, compile, out) {
+  let sites = 0;
+  for (const file of files) {
+    const text = file.bytes.toString("utf8");
+    if (!mentionsScenes(text)) continue;
+    const result = compileSites(file.path, text, compile);
+    sites += result.sites.length;
+    for (const d of result.diagnostics) out.push(toBuildDiagnostic(d));
+  }
+  return sites;
+}
+
+export { SCENES_FLAG, buildScenes, compileSites, formatSceneDiagnostic, sceneCompilerFromFlag, scenesEnabled };

package/dist/chunk-VSA44UKR.mjs

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+import { loadOrCreateSigningKey, registrationFor, withRegistration, writeSigningKey, signSource, signingKeyDir, remoteFromEnv } from './chunk-EGQIPYUN.mjs';
+import { CHANNELS, remoteCall, RemoteError } from './chunk-SCKQ4XSD.mjs';
+import { buildLocal, workPath, formatBytes, VERIFIED_MAX_SOURCE_SET_BYTES, requireInteractiveProject, UPLOAD_PART_BYTES } from './chunk-CPBESPWK.mjs';
+import { MANIFEST_FILE, assignInteractiveId } from './chunk-T4MW3PD4.mjs';
+import { refreshEngineRuntime } from './chunk-G2ZEFSQJ.mjs';
+import { sha256 } from './chunk-25ZPFHLF.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagString } from './chunk-XQAHREKO.mjs';
+import { CliError, CLI_ERROR_CODE, info, dim, step, failure, isJsonMode, warn, success, bold, result } from './chunk-KOD4GBQ5.mjs';
+import { promises } from 'fs';
+import os from 'os';
+import path from 'path';
+
+var UPLOAD_JOURNAL_FILE = "upload-journal.json";
+var JOURNAL_VERSION = 1;
+function sameKey(state, key) {
+  return state.version === JOURNAL_VERSION && state.origin === key.origin && state.interactiveId === key.interactiveId && state.channel === key.channel && state.sourceDigest === key.sourceDigest;
+}
+var UploadJournal = class _UploadJournal {
+  constructor(file, state, resumed) {
+    this.file = file;
+    this.state = state;
+    this.resumed = resumed;
+  }
+  file;
+  state;
+  resumed;
+  writing = Promise.resolve();
+  static memory(key) {
+    return new _UploadJournal(null, { ...key, version: JOURNAL_VERSION, revision: null, files: {} }, false);
+  }
+  static async open(file, key) {
+    try {
+      const state = JSON.parse(await promises.readFile(file, "utf8"));
+      if (sameKey(state, key)) return new _UploadJournal(file, state, state.revision !== null);
+    } catch (err) {
+      if (err.code !== "ENOENT" && !(err instanceof SyntaxError)) throw err;
+    }
+    return new _UploadJournal(file, { ...key, version: JOURNAL_VERSION, revision: null, files: {} }, false);
+  }
+  get revision() {
+    return this.state.revision;
+  }
+  setRevision(revision) {
+    this.state.revision = revision;
+    if (revision === null) this.state.files = {};
+    return this.flush();
+  }
+  partsFor(digest, size, partBytes) {
+    const known = this.state.files[digest];
+    if (known === void 0 || known.size !== size || known.partBytes !== partBytes) return null;
+    return known.parts;
+  }
+  donePartsOf(digest) {
+    return this.state.files[digest]?.done ?? [];
+  }
+  isComplete(digest) {
+    return this.state.files[digest]?.complete === true;
+  }
+  recordParts(digest, size, partBytes, parts) {
+    const known = this.state.files[digest];
+    const keep = known !== void 0 && known.size === size && known.partBytes === partBytes;
+    this.state.files[digest] = { size, partBytes, parts: [...parts], done: keep ? known.done : [], complete: keep ? known.complete : false };
+    return this.flush();
+  }
+  markPart(digest, part) {
+    const known = this.state.files[digest];
+    if (known === void 0 || known.done.includes(part)) return this.writing;
+    known.done.push(part);
+    known.done.sort((a, b) => a - b);
+    return this.flush();
+  }
+  markFile(digest, size) {
+    const known = this.state.files[digest];
+    if (known === void 0) this.state.files[digest] = { size, partBytes: 0, parts: [], done: [], complete: true };
+    else known.complete = true;
+    return this.flush();
+  }
+  flush() {
+    const file = this.file;
+    if (file === null) return this.writing;
+    const snapshot = `${JSON.stringify(this.state)}
+`;
+    this.writing = this.writing.then(async () => {
+      await promises.mkdir(path.dirname(file), { recursive: true });
+      const staged = `${file}.tmp`;
+      await promises.writeFile(staged, snapshot);
+      await promises.rename(staged, file);
+    });
+    return this.writing;
+  }
+  async remove() {
+    await this.writing;
+    if (this.file !== null) await promises.rm(this.file, { force: true });
+  }
+};
+
+// src/interactives/remote/upload.ts
+var UPLOADS_IN_FLIGHT = 4;
+function bufferSource(path3, digest, bytes) {
+  return { path: path3, digest, size: bytes.length, read: async (offset, length) => bytes.subarray(offset, offset + length) };
+}
+function partSizes(size, partBytes) {
+  const out = [];
+  for (let offset = 0; offset < size; offset += partBytes) out.push(Math.min(partBytes, size - offset));
+  return out;
+}
+async function partDigests(source, partBytes) {
+  const out = [];
+  let offset = 0;
+  for (const size of partSizes(source.size, partBytes)) {
+    out.push(sha256(await source.read(offset, size)));
+    offset += size;
+  }
+  return out;
+}
+async function drain(tasks, concurrency) {
+  let next = 0;
+  let failure2 = null;
+  const worker = async () => {
+    while (failure2 === null && next < tasks.length) {
+      const task = tasks[next++];
+      try {
+        await task();
+      } catch (err) {
+        if (failure2 === null) failure2 = err;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(concurrency, tasks.length)) }, worker));
+  if (failure2 !== null) throw failure2;
+}
+async function uploadSources(remote, sources, missing, options) {
+  const partBytes = options.partBytes ?? UPLOAD_PART_BYTES;
+  const concurrency = options.concurrency ?? UPLOADS_IN_FLIGHT;
+  const journal = options.journal;
+  const unique = /* @__PURE__ */ new Map();
+  for (const source of sources) if (!unique.has(source.digest)) unique.set(source.digest, source);
+  let totalBytes = 0;
+  for (const source of unique.values()) totalBytes += source.size;
+  let sentBytes = 0;
+  let skippedBytes = 0;
+  let uploadedFiles = 0;
+  let skippedFiles = 0;
+  let uploadedParts = 0;
+  let skippedParts = 0;
+  const report = (path3) => options.onProgress?.({ totalBytes, sentBytes, skippedBytes, path: path3 });
+  const skip = (bytes) => {
+    skippedBytes += bytes;
+  };
+  const whole = [];
+  const parted = [];
+  for (const source of unique.values()) {
+    if (!missing.has(source.digest)) {
+      skippedFiles++;
+      skip(source.size);
+    } else if (source.size > partBytes) parted.push(source);
+    else whole.push(source);
+  }
+  report(null);
+  const tasks = [];
+  for (const source of whole) {
+    tasks.push(async () => {
+      await remote.uploadFile(options.sessionId, source.digest, await source.read(0, source.size));
+      await journal.markFile(source.digest, source.size);
+      uploadedFiles++;
+      sentBytes += source.size;
+      report(source.path);
+    });
+  }
+  const planned = /* @__PURE__ */ new Map();
+  await drain(
+    parted.map((source) => async () => {
+      const digests = journal.partsFor(source.digest, source.size, partBytes) ?? await partDigests(source, partBytes);
+      await journal.recordParts(source.digest, source.size, partBytes, digests);
+      let offset = 0;
+      planned.set(
+        source.digest,
+        partSizes(source.size, partBytes).map((size, index) => {
+          const part = { number: index + 1, offset, size, digest: digests[index] };
+          offset += size;
+          return part;
+        })
+      );
+    }),
+    concurrency
+  );
+  for (const source of parted) {
+    const parts = planned.get(source.digest);
+    const opened = await remote.openUpload(
+      source.digest,
+      source.size,
+      parts.map((part) => part.digest)
+    );
+    if (opened.partBytes !== partBytes || opened.parts !== parts.length) {
+      throw new RemoteError("invalid", `the server splits ${source.path} into ${opened.parts} parts of ${opened.partBytes} bytes, not ${parts.length} of ${partBytes}`);
+    }
+    if (opened.stored) {
+      skippedFiles++;
+      skippedParts += parts.length;
+      skip(source.size);
+      await journal.markFile(source.digest, source.size);
+      continue;
+    }
+    const received = new Set(opened.received);
+    const pending = parts.filter((part) => !received.has(part.number));
+    for (const part of parts) {
+      if (!received.has(part.number)) continue;
+      skippedParts++;
+      skip(part.size);
+      await journal.markPart(source.digest, part.number);
+    }
+    let remaining = pending.length;
+    const finish = async () => {
+      await remote.completeUpload(source.digest);
+      await journal.markFile(source.digest, source.size);
+      uploadedFiles++;
+      report(source.path);
+    };
+    if (remaining === 0) {
+      tasks.push(finish);
+      continue;
+    }
+    for (const part of pending) {
+      tasks.push(async () => {
+        const bytes = await source.read(part.offset, part.size);
+        if (sha256(bytes) !== part.digest) {
+          throw new RemoteError("invalid", `${source.path} changed while it was uploading; publish again`);
+        }
+        await remote.uploadPart(source.digest, part.number, bytes);
+        await journal.markPart(source.digest, part.number);
+        uploadedParts++;
+        sentBytes += part.size;
+        report(source.path);
+        remaining--;
+        if (remaining === 0) await finish();
+      });
+    }
+  }
+  await drain(tasks, concurrency);
+  return { uploadedFiles, skippedFiles, uploadedParts, skippedParts, sentBytes, skippedBytes };
+}
+
+// src/interactives/commands/publish.ts
+var PROGRESS_STEP_PERCENT = 10;
+function parseChannel(value) {
+  if (value === void 0) return "live";
+  if (CHANNELS.indexOf(value) < 0) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `unknown channel '${value}'; expected ${CHANNELS.join(" or ")}`);
+  }
+  return value;
+}
+function keyLabel() {
+  return os.hostname();
+}
+async function registeredSigningKey(remote, keyDir) {
+  const key = await loadOrCreateSigningKey(keyDir);
+  if (registrationFor(key, remote.origin) !== null) return key;
+  const registered = await remote.registerSigningKey(key.rawPublicKey, keyLabel());
+  const next = withRegistration(key, { origin: remote.origin, keyId: registered.keyId });
+  await writeSigningKey(keyDir, next);
+  info(dim(`Registered signing key ${registered.keyId} with your account`));
+  return next;
+}
+async function ensureInteractiveId(root, remote, identity) {
+  if (identity.id !== null) return identity.id;
+  const created = await remote.createInteractive({ name: identity.name, description: identity.description, category: identity.category });
+  const manifestPath = path.join(root, MANIFEST_FILE);
+  await promises.writeFile(manifestPath, assignInteractiveId(await promises.readFile(manifestPath, "utf8"), created));
+  info(dim(`Assigned Interactive id ${created} and wrote it to ${MANIFEST_FILE}`));
+  return created;
+}
+async function publishProject(root, channel, deps) {
+  step("Building locally before upload");
+  let local = await buildLocal(root);
+  if (!local.result.ok || local.result.manifest === null) {
+    for (const d of local.result.diagnostics) failure(formatDiagnostic(d));
+    throw new CliError(CLI_ERROR_CODE.BUILD_FAILED, "the local build failed, so nothing was uploaded");
+  }
+  const identity = local.result.manifest.identity;
+  const key = await remoteCall(() => registeredSigningKey(deps.remote, deps.keyDir));
+  const interactiveId = await remoteCall(() => ensureInteractiveId(root, deps.remote, identity));
+  if (identity.id === null) local = await buildLocal(root);
+  const set = local.set;
+  const allowance = await remoteCall(() => deps.remote.sourceLimits());
+  if (allowance !== null) checkAllowance(set.files, allowance);
+  const journal = await UploadJournal.open(workPath(root, UPLOAD_JOURNAL_FILE), { origin: deps.remote.origin, interactiveId, channel, sourceDigest: set.digest });
+  const session = await openSession(deps.remote, journal, {
+    interactiveId,
+    channel,
+    sourceDigest: set.digest,
+    files: set.files.map((f) => ({ path: f.path, digest: f.digest, size: f.size })),
+    signature: signSource(key, set.digest)
+  });
+  const resumed = session.sessionId === journal.revision && journal.resumed;
+  step(resumed ? `Resuming the upload of ${set.files.length} files to the ${channel} channel` : `Uploading ${set.files.length} files to the ${channel} channel`);
+  const sent = await remoteCall(
+    () => uploadSources(
+      deps.remote,
+      set.files.map((f) => bufferSource(f.path, f.digest, f.bytes)),
+      new Set(session.missing),
+      { sessionId: session.sessionId, journal, partBytes: allowance?.partBytes, concurrency: deps.concurrency, onProgress: deps.onProgress ?? progressPrinter() }
+    )
+  );
+  step("Building and admitting on Cimplify");
+  const outcome = await remoteCall(() => deps.remote.commitPublish(session.sessionId));
+  await journal.remove();
+  return {
+    interactiveId,
+    channel,
+    files: set.files.length,
+    uploaded: sent.uploadedFiles,
+    skipped: set.files.length - sent.uploadedFiles,
+    sentBytes: sent.sentBytes,
+    skippedBytes: sent.skippedBytes,
+    resumed,
+    outcome
+  };
+}
+async function openSession(remote, journal, request) {
+  const revision = journal.revision;
+  if (revision !== null) {
+    const pending = await remoteCall(() => remote.pendingPublish(revision));
+    if (pending !== null) return { sessionId: revision, missing: pending.receiving ? pending.missing : [] };
+  }
+  const session = await remoteCall(() => remote.beginPublish(request));
+  await journal.setRevision(session.sessionId);
+  return session;
+}
+function checkAllowance(files, allowance) {
+  let total = 0;
+  for (const file of files) total += file.size;
+  if (total > allowance.sourceSetBytes) {
+    const remediation = allowance.verified ? `Trim the source set below ${formatBytes(allowance.sourceSetBytes)}.` : `Verify your creator account to publish up to ${formatBytes(VERIFIED_MAX_SOURCE_SET_BYTES)}, or trim the source set below ${formatBytes(allowance.sourceSetBytes)}.`;
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `the source set is ${formatBytes(total)}; your creator account publishes source sets up to ${formatBytes(allowance.sourceSetBytes)}`, { remediation });
+  }
+}
+function progressPrinter() {
+  const live = !isJsonMode() && Boolean(process.stdout.isTTY);
+  let shown = -1;
+  return (progress) => {
+    if (isJsonMode() || progress.totalBytes === 0) return;
+    const done = progress.sentBytes + progress.skippedBytes;
+    const percent = Math.floor(done * 100 / progress.totalBytes);
+    const line = `  ${percent}% ${formatBytes(done)} of ${formatBytes(progress.totalBytes)}${progress.skippedBytes > 0 ? `, ${formatBytes(progress.skippedBytes)} already on Cimplify` : ""}`;
+    if (live) {
+      process.stdout.write(`\r${line}${percent === 100 ? "\n" : ""}`);
+      return;
+    }
+    if (percent === shown || percent < 100 && percent - shown < PROGRESS_STEP_PERCENT) return;
+    shown = percent;
+    info(dim(line));
+  };
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const root = process.cwd();
+  requireInteractiveProject(root, "publish");
+  const channel = parseChannel(flagString(args, "channel"));
+  await refreshEngineRuntime(root);
+  const summary = await publishProject(root, channel, { remote: await remoteFromEnv(), keyDir: signingKeyDir() });
+  info(dim(`  ${summary.uploaded} uploaded (${formatBytes(summary.sentBytes)}), ${summary.skipped} unchanged and skipped (${formatBytes(summary.skippedBytes)})${summary.resumed ? ", resumed" : ""}`));
+  for (const log of summary.outcome.logs) {
+    const line = `  ${dim(log.at)} ${log.message}`;
+    if (log.level === "error") failure(line);
+    else if (log.level === "warning") warn(line);
+    else info(line);
+  }
+  const rev = summary.outcome.revision;
+  if (rev.state === "refused") {
+    throw new CliError(CLI_ERROR_CODE.BUILD_FAILED, `revision ${rev.revision} was refused at admission`);
+  }
+  if (rev.state === "in_review") success(`Revision ${bold(rev.revision)} passed admission checks and waits for review before release to ${channel}`);
+  else success(`Published ${bold(rev.revision)} to ${channel} (${rev.packageDigest})`);
+  result({
+    interactive_id: summary.interactiveId,
+    channel,
+    revision: rev.revision,
+    state: rev.state,
+    package_digest: rev.packageDigest,
+    source_digest: rev.sourceDigest,
+    uploaded: summary.uploaded,
+    skipped: summary.skipped,
+    sent_bytes: summary.sentBytes,
+    skipped_bytes: summary.skippedBytes,
+    resumed: summary.resumed
+  });
+}
+
+export { checkAllowance, keyLabel, parseChannel, progressPrinter, publishProject, registeredSigningKey, run };