weaver-work-cli 0.1.28 → 0.1.31

package/dist/chunks/chunk-EG6ZU444.js

@@ -0,0 +1,654 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  refsDir,
+  refsIndexPath
+} from "./chunk-AJ62BGAW.js";
+import {
+  CliError
+} from "./chunk-LUSPKZKY.js";
+
+// src/core/refs.ts
+import { createHash, randomBytes } from "node:crypto";
+import {
+  appendFileSync,
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  statSync,
+  truncateSync,
+  writeFileSync
+} from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+var REF_SCHEMA_VERSION = 1;
+var RefError = class extends CliError {
+  type = "policy";
+  subtype;
+  retryable = false;
+  constructor(subtype, message, exitCode = 2 /* UsageError */) {
+    super(message, exitCode);
+    this.name = "RefError";
+    this.subtype = subtype;
+  }
+};
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function refIdFor(operation, now = /* @__PURE__ */ new Date()) {
+  const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const name = operation ? slug(operation) : "result";
+  return `${stamp}-${name || "result"}-${randomBytes(8).toString("hex")}`;
+}
+function dateDirOf(now) {
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+function sha256Of(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") {
+    chmodSync(dir, 448);
+  }
+}
+function ensurePrivateFile(file) {
+  if (process.platform !== "win32") {
+    chmodSync(file, 384);
+  }
+}
+function isInsideRefs(ctx, file) {
+  const root = resolve(refsDir(ctx));
+  const absolute = resolve(file);
+  const isChild = (parent, candidate) => {
+    const relativePath = relative(parent, candidate);
+    return relativePath !== "" && relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+  };
+  if (!isChild(root, absolute)) return false;
+  try {
+    return isChild(realpathSync(root), realpathSync(absolute));
+  } catch {
+    return false;
+  }
+}
+function writeFileDirectSync(file, data) {
+  writeFileSync(file, data, { encoding: "utf8", mode: 384 });
+  ensurePrivateFile(file);
+}
+function dropRefFile(file) {
+  try {
+    truncateSync(file, 0);
+    return true;
+  } catch (error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+  }
+}
+function readIndex(ctx) {
+  const path = refsIndexPath(ctx);
+  if (!existsSync(path)) return [];
+  const rows = [];
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed.refId === "string" && typeof parsed.file === "string" && typeof parsed.bytes === "number" && Number.isFinite(parsed.bytes) && parsed.bytes >= 0 && typeof parsed.sha256 === "string" && /^[a-f0-9]{64}$/u.test(parsed.sha256) && isInsideRefs(ctx, parsed.file)) rows.push({ ...parsed, file: resolve(parsed.file) });
+    } catch {
+    }
+  }
+  return rows;
+}
+function writeIndex(ctx, rows) {
+  ensureDir(refsDir(ctx));
+  const data = rows.map((row) => JSON.stringify(row)).join("\n");
+  writeFileDirectSync(refsIndexPath(ctx), rows.length ? `${data}
+` : "");
+}
+function appendIndex(ctx, meta) {
+  ensureDir(refsDir(ctx));
+  try {
+    appendFileSync(refsIndexPath(ctx), `${JSON.stringify(meta)}
+`, { encoding: "utf8", mode: 384 });
+    ensurePrivateFile(refsIndexPath(ctx));
+  } catch {
+  }
+}
+function scanFiles(ctx) {
+  const root = refsDir(ctx);
+  if (!existsSync(root)) return [];
+  const files = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dir = join(root, entry.name);
+    for (const inner of readdirSync(dir, { withFileTypes: true })) {
+      if (inner.isFile() && inner.name.endsWith(".json")) files.push(join(dir, inner.name));
+    }
+  }
+  return files;
+}
+function metaFromFile(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (!parsed || typeof parsed.refId !== "string") return null;
+    return {
+      refId: parsed.refId,
+      ...parsed.operation ? { operation: parsed.operation } : {},
+      file,
+      bytes: statSync(file).size,
+      sha256: sha256Of(JSON.stringify(parsed.envelope ?? null, null, 2)),
+      createdAt: parsed.createdAt,
+      expiresAt: parsed.expiresAt,
+      ttlMs: typeof parsed.ttlMs === "number" ? parsed.ttlMs : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function findMeta(ctx, refId) {
+  const fromIndex = readIndex(ctx).find((row) => row.refId === refId);
+  if (fromIndex) return fromIndex;
+  for (const file of scanFiles(ctx)) {
+    if (basename(file, ".json") === refId) {
+      const meta = metaFromFile(file);
+      if (meta) return meta;
+    }
+  }
+  return null;
+}
+function defaultTtlMs() {
+  return 30 * 6e4;
+}
+function writeRef(ctx, options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const ttlMs = options.ttlMs ?? defaultTtlMs();
+  const refId = refIdFor(options.operation, now);
+  const dir = join(refsDir(ctx), dateDirOf(now));
+  ensureDir(dir);
+  const file = join(dir, `${refId}.json`);
+  const payload = {
+    schemaVersion: REF_SCHEMA_VERSION,
+    refId,
+    ...options.operation ? { operation: options.operation } : {},
+    createdAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+    ttlMs,
+    envelope: options.value ?? null
+  };
+  const fileContents = JSON.stringify(payload, null, 2);
+  writeFileDirectSync(file, fileContents);
+  const meta = {
+    refId,
+    ...options.operation ? { operation: options.operation } : {},
+    file,
+    bytes: Buffer.byteLength(fileContents, "utf8"),
+    sha256: sha256Of(JSON.stringify(options.value ?? null, null, 2)),
+    createdAt: payload.createdAt,
+    expiresAt: payload.expiresAt,
+    ttlMs
+  };
+  appendIndex(ctx, meta);
+  return meta;
+}
+function readRef(ctx, refId) {
+  const meta = findMeta(ctx, refId);
+  if (!meta || !isInsideRefs(ctx, meta.file) || !existsSync(meta.file)) {
+    throw new RefError("ref_missing", `\u672A\u627E\u5230\u7ED3\u679C\u5F15\u7528\uFF1A${refId}`);
+  }
+  try {
+    if (!lstatSync(meta.file).isFile()) {
+      throw new RefError("ref_corrupt", `\u7ED3\u679C\u5F15\u7528\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${refId}`, 6 /* PolicyError */);
+    }
+  } catch (error) {
+    if (error instanceof RefError) throw error;
+    throw new RefError("ref_missing", `\u672A\u627E\u5230\u7ED3\u679C\u5F15\u7528\uFF1A${refId}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(meta.file, "utf8"));
+  } catch {
+    throw new RefError("ref_corrupt", `\u7ED3\u679C\u5F15\u7528\u6587\u4EF6\u635F\u574F\uFF1A${refId}`, 6 /* PolicyError */);
+  }
+  if (parsed.schemaVersion !== REF_SCHEMA_VERSION || parsed.refId !== refId || typeof parsed.createdAt !== "string" || typeof parsed.expiresAt !== "string" || !Number.isFinite(Date.parse(parsed.createdAt)) || !Number.isFinite(Date.parse(parsed.expiresAt)) || parsed.createdAt !== meta.createdAt || parsed.expiresAt !== meta.expiresAt || parsed.ttlMs !== meta.ttlMs) {
+    throw new RefError("ref_corrupt", `\u7ED3\u679C\u5F15\u7528\u5143\u6570\u636E\u4E0D\u5339\u914D\uFF1A${refId}`, 6 /* PolicyError */);
+  }
+  const expiresAt = Date.parse(parsed.expiresAt);
+  if (expiresAt < Date.now()) {
+    dropRefFile(meta.file);
+    writeIndex(ctx, readIndex(ctx).filter((row) => row.refId !== refId));
+    throw new RefError("ref_expired", `\u7ED3\u679C\u5F15\u7528\u5DF2\u8FC7\u671F\uFF1A${refId}`, 6 /* PolicyError */);
+  }
+  const serialized = JSON.stringify(parsed.envelope ?? null, null, 2);
+  if (sha256Of(serialized) !== meta.sha256) {
+    throw new RefError("ref_corrupt", `\u7ED3\u679C\u5F15\u7528\u6821\u9A8C\u5931\u8D25\uFF1A${refId}`, 6 /* PolicyError */);
+  }
+  return { meta, envelope: parsed.envelope };
+}
+function listRefs(ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  const rows = [];
+  for (const row of readIndex(ctx)) {
+    if (seen.has(row.refId) || !existsSync(row.file)) continue;
+    seen.add(row.refId);
+    rows.push(row);
+  }
+  for (const file of scanFiles(ctx)) {
+    const id = basename(file, ".json");
+    if (seen.has(id)) continue;
+    const meta = metaFromFile(file);
+    if (meta) {
+      seen.add(id);
+      rows.push(meta);
+    }
+  }
+  return rows.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+}
+function pruneRefs(ctx, options = {}) {
+  const maxCount = options.maxCount ?? 50;
+  const maxBytes = options.maxBytes ?? 200 * 1024 * 1024;
+  const preserved = new Set(options.preserveRefIds ?? []);
+  const rows = listRefs(ctx);
+  const now = Date.now();
+  const expired = [];
+  const alive = [];
+  const ageCutoff = options.olderThanMs === void 0 ? void 0 : now - options.olderThanMs;
+  for (const row of rows) {
+    const at = Date.parse(row.expiresAt);
+    const created = Date.parse(row.createdAt);
+    const tooOld = ageCutoff !== void 0 && Number.isFinite(created) && created <= ageCutoff;
+    if ((Number.isFinite(at) && at < now || tooOld) && !preserved.has(row.refId)) expired.push(row);
+    else alive.push(row);
+  }
+  const byAge = [...alive].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
+  const victims = new Set(expired.map((row) => row.refId));
+  const protectedRows = byAge.filter((row) => preserved.has(row.refId));
+  const candidates = byAge.filter((row) => !preserved.has(row.refId));
+  const allowedCandidates = Math.max(0, Math.floor(maxCount) - protectedRows.length);
+  if (candidates.length > allowedCandidates) {
+    for (const row of candidates.slice(0, candidates.length - allowedCandidates)) victims.add(row.refId);
+  }
+  let total = byAge.filter((row) => !victims.has(row.refId)).reduce((sum, row) => sum + row.bytes, 0);
+  if (total > maxBytes) {
+    for (const row of candidates) {
+      if (total <= maxBytes) break;
+      if (victims.has(row.refId)) continue;
+      victims.add(row.refId);
+      total -= row.bytes;
+    }
+  }
+  let cleanupIncomplete = false;
+  for (const row of rows) {
+    if (!victims.has(row.refId)) continue;
+    if (!dropRefFile(row.file)) cleanupIncomplete = true;
+  }
+  const kept = rows.filter((row) => !victims.has(row.refId));
+  if (rows.length > 0 || existsSync(refsIndexPath(ctx))) writeIndex(ctx, kept);
+  const keptBytes = kept.reduce((sum, row) => sum + row.bytes, 0);
+  return {
+    removed: victims.size,
+    kept: kept.length,
+    bytes: keptBytes,
+    overLimit: cleanupIncomplete || kept.length > maxCount || keptBytes > maxBytes,
+    cleanupIncomplete
+  };
+}
+function pickValue(value, path) {
+  let cursor = value;
+  for (const token of tokenizePath(path)) {
+    if (cursor === null || cursor === void 0) {
+      throw new RefError("ref_pick_failed", `--pick \u8DEF\u5F84 ${path} \u5728 ${token} \u5904\u65E0\u6CD5\u7EE7\u7EED`);
+    }
+    if (typeof token === "number") {
+      if (!Array.isArray(cursor)) {
+        throw new RefError("ref_pick_failed", `--pick \u8DEF\u5F84 ${path} \u7684 ${token} \u4E0D\u662F\u6570\u7EC4\u4E0B\u6807\u53EF\u8BBF\u95EE\u7684\u503C`);
+      }
+      cursor = cursor[token];
+      continue;
+    }
+    if (typeof cursor !== "object") {
+      throw new RefError("ref_pick_failed", `--pick \u8DEF\u5F84 ${path} \u65E0\u6CD5\u4ECE\u975E\u5BF9\u8C61\u4E2D\u53D6\u5B57\u6BB5 ${token}`);
+    }
+    const holder = cursor;
+    if (!(token in holder)) {
+      throw new RefError("ref_pick_failed", `--pick \u8DEF\u5F84 ${path} \u4E2D\u4E0D\u5B58\u5728\u5B57\u6BB5 ${token}`);
+    }
+    cursor = holder[token];
+  }
+  return cursor;
+}
+function tokenizePath(path) {
+  let cursor = path.trim().replace(/^\$/, "").replace(/^data\./, "");
+  const tokens = [];
+  const pattern = /([^.[\]]+)|\[(\d+)\]/g;
+  let match;
+  while ((match = pattern.exec(cursor)) !== null) {
+    if (match[1] !== void 0) tokens.push(match[1]);
+    else tokens.push(Number(match[2]));
+  }
+  if (!tokens.length) {
+    throw new RefError("ref_pick_failed", `\u65E0\u6CD5\u89E3\u6790 --pick \u8DEF\u5F84\uFF1A${path}`);
+  }
+  return tokens;
+}
+function resolveRefInput(ctx, options) {
+  const { envelope } = readRef(ctx, options.refId);
+  const data = envelope && typeof envelope === "object" && !Array.isArray(envelope) && "data" in envelope ? envelope.data : envelope;
+  const target = options.pick ? pickValue(data, options.pick) : data;
+  if (target && typeof target === "object" && !Array.isArray(target)) {
+    if (options.pickAs) {
+      throw new RefError("ref_pick_as_object", "--pick-as \u53EA\u7528\u4E8E\u628A\u5355\u4E2A\u503C\u6620\u5C04\u5230\u8F93\u5165\u5B57\u6BB5\uFF1B\u5F53\u524D\u9009\u62E9\u7ED3\u679C\u5DF2\u7ECF\u662F\u5BF9\u8C61");
+    }
+    return target;
+  }
+  if (!options.pickAs || !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(options.pickAs)) {
+    throw new RefError(
+      "ref_pick_scalar_requires_key",
+      "\u9009\u62E9\u7ED3\u679C\u662F\u5355\u4E2A\u503C\uFF1B\u8BF7\u52A0 --pick-as <\u8F93\u5165\u5B57\u6BB5\u540D>\uFF0C\u4F8B\u5982 --pick items[0].fid --pick-as fid"
+    );
+  }
+  return { [options.pickAs]: target ?? null };
+}
+
+// src/core/output.ts
+var DEFAULT_RESULT_THRESHOLD_BYTES = 24 * 1024;
+var DEFAULT_REF_TTL_MS = 30 * 6e4;
+var DEFAULT_REF_MAX_COUNT = 50;
+var DEFAULT_REF_MAX_BYTES = 200 * 1024 * 1024;
+var COMPACT_TIERS = [
+  { array: 10, string: 200 },
+  { array: 5, string: 80 },
+  { array: 2, string: 40 },
+  { array: 1, string: 20 }
+];
+function numberFromEnv(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function configValue(ctx, key) {
+  const io = ctx.config.get("io");
+  if (io && typeof io === "object" && !Array.isArray(io)) {
+    const holder = io;
+    if (key in holder) return holder[key];
+  }
+  return ctx.config.get(key);
+}
+function numeric(ctx, envName, configKey, fallback) {
+  const fromEnv = numberFromEnv(envName);
+  if (fromEnv !== void 0) return fromEnv;
+  const fromConfig = configValue(ctx, configKey);
+  if (typeof fromConfig === "number" && Number.isFinite(fromConfig)) return fromConfig;
+  return fallback;
+}
+function resultThresholdBytes(ctx) {
+  const value = numeric(ctx, "WEAVER_WORK_CLI_REF_THRESHOLD", "resultThreshold", DEFAULT_RESULT_THRESHOLD_BYTES);
+  return value === 0 || value >= 2 * 1024 ? Math.floor(value) : DEFAULT_RESULT_THRESHOLD_BYTES;
+}
+function refTtlMs(ctx) {
+  const value = numeric(ctx, "WEAVER_WORK_CLI_REF_TTL_MS", "refTtlMs", DEFAULT_REF_TTL_MS);
+  return value >= 1 ? Math.floor(value) : DEFAULT_REF_TTL_MS;
+}
+function refMaxCount(ctx) {
+  const value = numeric(ctx, "WEAVER_WORK_CLI_REF_MAX_COUNT", "refMaxCount", DEFAULT_REF_MAX_COUNT);
+  return value >= 1 ? Math.floor(value) : DEFAULT_REF_MAX_COUNT;
+}
+function refMaxBytes(ctx) {
+  const value = numeric(ctx, "WEAVER_WORK_CLI_REF_MAX_BYTES", "refMaxBytes", DEFAULT_REF_MAX_BYTES);
+  return value >= 1 ? Math.floor(value) : DEFAULT_REF_MAX_BYTES;
+}
+function bytesOf(value) {
+  return Buffer.byteLength(JSON.stringify(value ?? null, null, 2), "utf8");
+}
+function compactValue(value, arrayLimit, stringLimit, depth = 0) {
+  if (depth > 6) return "<omitted: too deep>";
+  if (typeof value === "string") {
+    return value.length > stringLimit ? `${value.slice(0, stringLimit)}\u2026(truncated ${value.length - stringLimit} chars)` : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, arrayLimit).map((item) => compactValue(item, arrayLimit, stringLimit, depth + 1));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+      out[key] = compactValue(inner, arrayLimit, stringLimit, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+function compactRecord(value, budgetBytes, keepKeys) {
+  let current = value;
+  for (const tier of COMPACT_TIERS) {
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+      out[key] = keepKeys.includes(key) ? inner : compactValue(inner, tier.array, tier.string);
+    }
+    current = out;
+    if (bytesOf(out) <= budgetBytes) return out;
+  }
+  return current;
+}
+function skeletonOf(value, keepKeys, hasRef = true) {
+  const out = {};
+  const recoveryHint = hasRef ? "use --input-ref" : "result unavailable";
+  for (const [key, inner] of Object.entries(value)) {
+    if (keepKeys.includes(key)) {
+      out[key] = key === "error" ? compactError(inner) : inner;
+    } else if (Array.isArray(inner)) {
+      out[key] = `<omitted: ${inner.length} items, ${recoveryHint}>`;
+    } else if (inner && typeof inner === "object") {
+      out[key] = `<omitted: ${Object.keys(inner).length} keys, ${recoveryHint}>`;
+    } else if (typeof inner === "string") {
+      out[key] = inner.length > 160 ? `${inner.slice(0, 160)}\u2026(truncated)` : inner;
+    } else {
+      out[key] = inner;
+    }
+  }
+  return out;
+}
+var ENVELOPE_KEEP_KEYS = [
+  "schemaVersion",
+  "ok",
+  "operation",
+  "status",
+  "error"
+];
+function compactError(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const error = value;
+  const out = {};
+  for (const key of ["type", "subtype", "code", "retryable", "stage"]) {
+    if (error[key] !== void 0) out[key] = error[key];
+  }
+  if (typeof error.message === "string") {
+    out.message = error.message.length > 240 ? `${error.message.slice(0, 240)}\u2026(truncated)` : error.message;
+  }
+  if (error.details !== void 0) out.details = "<omitted: see the error subtype and message>";
+  return out;
+}
+function operationOf(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const operation = value.operation;
+    if (typeof operation === "string") return operation;
+  }
+  return void 0;
+}
+function warningsOf(value) {
+  const warnings = value.warnings;
+  return Array.isArray(warnings) ? warnings : [];
+}
+function withLeadingMeta(value, leading, body, extraWarnings) {
+  const base = value && typeof value === "object" && !Array.isArray(value) ? value : { data: value };
+  const reserved = /* @__PURE__ */ new Set([...Object.keys(leading), "warnings"]);
+  const safeBody = Object.fromEntries(Object.entries(body).filter(([key]) => !reserved.has(key)));
+  const compactWarnings = Object.prototype.hasOwnProperty.call(body, "warnings") ? Array.isArray(body.warnings) ? body.warnings : [body.warnings] : warningsOf(base);
+  return {
+    ...leading,
+    ...safeBody,
+    warnings: [...compactWarnings, ...extraWarnings]
+  };
+}
+function slimmedBody(value, threshold, hasRef) {
+  const base = value && typeof value === "object" && !Array.isArray(value) ? value : { data: value };
+  const compacted = compactRecord(base, threshold, ENVELOPE_KEEP_KEYS);
+  if (bytesOf(compacted) <= threshold) return compacted;
+  return skeletonOf(base, ENVELOPE_KEEP_KEYS, hasRef);
+}
+function fitEnvelope(value, leading, extraWarnings, budgetBytes) {
+  const hasRef = leading.resultPersisted === true;
+  const body = slimmedBody(value, budgetBytes, hasRef);
+  let envelope = withLeadingMeta(value, leading, body, extraWarnings);
+  if (bytesOf(envelope) <= budgetBytes) return envelope;
+  const base = value && typeof value === "object" && !Array.isArray(value) ? value : { data: value };
+  envelope = withLeadingMeta(
+    value,
+    leading,
+    skeletonOf(base, ENVELOPE_KEEP_KEYS, leading.resultPersisted === true),
+    extraWarnings
+  );
+  if (bytesOf(envelope) <= budgetBytes) return envelope;
+  const persisted = leading.resultPersisted === true;
+  const refId = String(leading.refId ?? "").slice(0, 80);
+  return {
+    ...persisted ? { refId } : {},
+    resultPersisted: persisted,
+    outputBytes: Number(leading.outputBytes) || 0,
+    largeOutputNotice: persisted ? `\u7ED3\u679C\u5DF2\u7CBE\u7B80\uFF0C\u4F7F\u7528 --input-ref ${refId} \u8BFB\u53D6\u3002` : "\u7ED3\u679C\u65E0\u6CD5\u6682\u5B58\uFF1Bstdout \u4EC5\u4FDD\u7559\u7CBE\u7B80\u5185\u5BB9\uFF0C\u5B8C\u6574\u7ED3\u679C\u4E0D\u53EF\u6062\u590D\u3002",
+    previewTruncated: true,
+    schemaVersion: typeof base.schemaVersion === "number" || typeof base.schemaVersion === "string" ? String(base.schemaVersion).slice(0, 20) : 1,
+    ok: typeof base.ok === "boolean" ? base.ok : true,
+    ...typeof base.operation === "string" ? { operation: base.operation.slice(0, 80) } : {},
+    ...base.error === void 0 ? {} : { error: compactError(base.error) },
+    data: persisted ? "<omitted: use --input-ref>" : "<omitted: full result unavailable>",
+    warnings: [...extraWarnings, "stdout_compacted"]
+  };
+}
+function stringifyForStdout(value, compactPaths) {
+  const wanted = new Set((compactPaths ?? []).filter((path) => typeof path === "string" && path !== ""));
+  const plain = JSON.stringify(value, null, 2);
+  if (!wanted.size || plain === void 0) return plain;
+  let salt = "";
+  do {
+    salt = `__WEAVER_COMPACT_${Math.random().toString(36).slice(2, 12)}__`;
+  } while (plain.includes(salt));
+  const compacted = [];
+  const swap = (node, path) => {
+    if (node !== null && typeof node === "object" && wanted.has(path)) {
+      const inline = JSON.stringify(node);
+      if (inline !== void 0) {
+        compacted.push(inline);
+        return `${salt}${compacted.length - 1}__`;
+      }
+    }
+    if (Array.isArray(node)) return node.map((item, index) => swap(item, `${path}[${index}]`));
+    if (node !== null && typeof node === "object") {
+      const out = {};
+      for (const [key, item] of Object.entries(node)) {
+        out[key] = swap(item, path ? `${path}.${key}` : key);
+      }
+      return out;
+    }
+    return node;
+  };
+  const swapped = JSON.stringify(swap(value, ""), null, 2);
+  if (typeof swapped !== "string") return swapped;
+  return swapped.replace(
+    new RegExp(`"${salt}(\\d+)__"`, "g"),
+    (_match, index) => compacted[Number(index)] ?? "null"
+  );
+}
+var Output = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  write(value, options = {}) {
+    const globalOptions = this.ctx.getGlobalOptions();
+    const useJson = globalOptions.json || options.json || !options.text;
+    if (!useJson) {
+      console.log(options.text);
+      return;
+    }
+    console.log(stringifyForStdout(this.prepare(value, options), options.compactPaths));
+  }
+  prepare(value, options) {
+    const threshold = resultThresholdBytes(this.ctx);
+    if (options.persist === false || threshold <= 0) return value;
+    const finalBudget = Math.max(1024, threshold - 1024);
+    const bytes = bytesOf(value);
+    if (bytes <= threshold) return value;
+    const limits = { maxCount: refMaxCount(this.ctx), maxBytes: refMaxBytes(this.ctx) };
+    const warnings = [];
+    try {
+      try {
+        pruneRefs(this.ctx, limits);
+      } catch {
+        warnings.push("ref_gc_failed");
+      }
+      const meta = writeRef(this.ctx, { value, operation: operationOf(value), ttlMs: refTtlMs(this.ctx) });
+      let retention;
+      try {
+        retention = pruneRefs(this.ctx, { ...limits, preserveRefIds: [meta.refId] });
+      } catch {
+        warnings.push("ref_gc_failed");
+      }
+      if (retention?.overLimit) warnings.push("ref_store_over_limit");
+      if (retention?.cleanupIncomplete) warnings.push("ref_gc_incomplete");
+      return fitEnvelope(value, this.leadingFor(meta, bytes, retention), warnings, finalBudget);
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+      const message = code === "ENOSPC" ? "\u78C1\u76D8\u7A7A\u95F4\u4E0D\u8DB3" : code === "EACCES" || code === "EPERM" ? "CLI \u6682\u5B58\u76EE\u5F55\u65E0\u5199\u5165\u6743\u9650" : "\u65E0\u6CD5\u5199\u5165 CLI \u6682\u5B58\u76EE\u5F55";
+      process.stderr.write(
+        `[weaver-work-cli] \u7ED3\u679C ${bytes} \u5B57\u8282\u8D85\u8FC7 stdout \u9884\u7B97 ${threshold} \u5B57\u8282\u4E14\u843D\u76D8\u5931\u8D25\uFF0C\u8F93\u51FA\u5DF2\u7CBE\u7B80\uFF1A${message}
+`
+      );
+      return fitEnvelope(
+        value,
+        {
+          outputBytes: bytes,
+          resultPersisted: false,
+          largeOutputNotice: `\u7ED3\u679C\u8D85\u8FC7 stdout \u9650\u5236\u4E14\u65E0\u6CD5\u6682\u5B58\uFF1B\u5F53\u524D\u5185\u5BB9\u5DF2\u7CBE\u7B80\uFF0C\u53EF\u80FD\u4E0D\u5B8C\u6574\uFF1A${message.slice(0, 160)}`
+        },
+        ["result_persist_failed"],
+        finalBudget
+      );
+    }
+  }
+  leadingFor(meta, bytes, retention) {
+    const retentionNotice = retention?.cleanupIncomplete ? " \u90E8\u5206\u65E7\u5F15\u7528\u6682\u65F6\u65E0\u6CD5\u5220\u9664\uFF0CCLI \u4F1A\u5728\u540E\u7EED\u547D\u4EE4\u91CD\u8BD5\u3002" : retention?.overLimit ? " \u672C\u7ED3\u679C\u8D85\u8FC7\u6682\u5B58\u5BB9\u91CF\u4E0A\u9650\uFF0C\u5DF2\u4FDD\u7559\u672C\u6B21\u7ED3\u679C\u5E76\u6DD8\u6C70\u65E7\u7ED3\u679C\u3002" : "";
+    return {
+      refId: meta.refId,
+      resultPersisted: true,
+      outputBytes: bytes,
+      sha256: meta.sha256,
+      expiresAt: meta.expiresAt,
+      previewTruncated: true,
+      largeOutputNotice: `\u7ED3\u679C ${bytes} \u5B57\u8282\u5DF2\u6682\u5B58\u3002\u4F7F\u7528 --input-ref ${meta.refId} \u5F15\u7528\uFF1B\u53D6\u5355\u4E2A\u5B57\u6BB5\u65F6\u52A0 --pick-as <\u5B57\u6BB5\u540D>\u3002` + retentionNotice
+    };
+  }
+  raw(message) {
+    console.log(message);
+  }
+};
+
+export {
+  RefError,
+  readRef,
+  listRefs,
+  pruneRefs,
+  pickValue,
+  resolveRefInput,
+  DEFAULT_RESULT_THRESHOLD_BYTES,
+  resultThresholdBytes,
+  refMaxCount,
+  refMaxBytes,
+  bytesOf,
+  stringifyForStdout,
+  Output
+};