stitchkit 0.104.2 → 0.105.0

package/dist/entrypoints/cli/publish.js

@@ -0,0 +1,527 @@
+import"../../index-xqhede6x.js";
+import"../../index-cq59agna.js";
+import {
+  ManagedFileError2,
+  createManagedFileBoundary2
+} from "../../index-wqmvtnkp.js";
+import"../../index-dsnjzb62.js";
+import"../../index-azx12jgv.js";
+import"../../index-v5ee8ath.js";
+import {
+  signCliManifest2,
+  verifyCliManifest2,
+  cliSignatureAccepted2,
+  CliBuildTargetSchema2,
+  CliBuildManifestSchema2,
+  assertCliPublishable2,
+  waitForPublication,
+  withPublicationDeadline,
+  collectCliBytes,
+  gzipCliAsset,
+  decodeCliAsset,
+  compareCliVersions2
+} from "../../index-szybbezc.js";
+import {
+  withExclusiveLock2
+} from "../../index-4vsby8n8.js";
+import {
+  writeFileAtomic2
+} from "../../index-ef8gdaq0.js";
+import {
+  AtomicFilePublicationError2,
+  assertDirectoryDurability,
+  syncDirectory
+} from "../../index-b56nnscm.js";
+import {
+  MAX_TIMER_MS
+} from "../../index-eemvahkc.js";
+
+// src/tools/cli/publication.ts
+import { createHash } from "node:crypto";
+import { lstat as lstat2, mkdtemp, rename, rm as rm2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { z as z3 } from "zod";
+
+// src/tools/cli/publication-contract.ts
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+var positive = z.int().positive().max(Number.MAX_SAFE_INTEGER);
+var timer = positive.max(MAX_TIMER_MS);
+var component = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/);
+var PublicationTargetSchema = CliBuildTargetSchema2.extend({
+  platform: component,
+  arch: component
+});
+var PublicationVersionSchema = z.string().max(128).regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?(?:\+[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?$/).refine((value) => {
+  const core = value.split(/[+-]/)[0];
+  if (!core || core.split(".").some((part) => !Number.isSafeInteger(Number(part))))
+    return false;
+  const prerelease = value.split("+")[0]?.split("-").slice(1).join("-");
+  return !prerelease || prerelease.split(".").every((part) => !/^\d+$/.test(part) || part === "0" || !part.startsWith("0"));
+}, "version must use finite canonical semver numbers");
+var limitsSchema = z.object({
+  maxTargets: positive.default(16),
+  maxManifestBytes: positive.default(256 * 1024),
+  maxAssetBytes: positive.default(256 * 1024 * 1024),
+  maxCompressedBytes: positive.default(256 * 1024 * 1024),
+  maxDirectoryEntries: positive.default(128),
+  maxStoredVersions: positive.min(3).default(16),
+  lockTimeoutMs: timer.default(1e4),
+  timeoutMs: timer.default(600000)
+});
+var dataSchema = CliBuildManifestSchema2.pick({
+  name: true,
+  version: true,
+  commit: true
+}).extend({
+  name: component,
+  version: PublicationVersionSchema,
+  commit: z.string().min(1).max(128),
+  storageRoot: z.string().min(1).refine(isAbsolute, "storageRoot must be absolute"),
+  baseUrl: z.url().refine((raw) => {
+    const url = new URL(raw);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
+  }, "baseUrl must be an http(s) directory URL without credentials/query/fragment"),
+  targets: z.array(PublicationTargetSchema).min(1),
+  limits: limitsSchema.prefault({}),
+  retention: positive.min(2).default(2)
+});
+var phaseSchema = z.enum(["prepare", "build", "commit", "promote"]);
+function publicationData(options) {
+  const data = dataSchema.parse(options);
+  if (data.targets.length > data.limits.maxTargets)
+    throw new RangeError("CLI publication target cap exceeded");
+  if (data.targets.length + 1 > data.limits.maxDirectoryEntries)
+    throw new RangeError("CLI version layout exceeds directory entry cap");
+  if (data.retention >= data.limits.maxStoredVersions)
+    throw new RangeError("retention must leave one recovery slot below maxStoredVersions");
+  const names = data.targets.map((target) => assetFilename(data.name, target));
+  if (new Set(names).size !== names.length)
+    throw new TypeError("CLI publication targets must be unique");
+  if (typeof options.admit !== "function" || typeof options.build !== "function")
+    throw new TypeError("CLI publication needs build and admit callbacks");
+  return data;
+}
+function assetFilename(name, target) {
+  return `${name}-${target.platform}-${target.arch}.gz`;
+}
+function assetUrl(baseUrl, version, filename) {
+  return new URL(`${encodeURIComponent(version)}/${encodeURIComponent(filename)}`, `${baseUrl.replace(/\/+$/, "")}/`).toString();
+}
+
+// src/tools/cli/publication-storage.ts
+import { lstat, mkdir, opendir, realpath, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { z as z2 } from "zod";
+async function directoryGeneration(path) {
+  const info = await lstat(path);
+  if (!info.isDirectory() || info.isSymbolicLink())
+    throw new Error("CLI storage directory must not be a link or non-directory");
+  return { dev: info.dev, ino: info.ino };
+}
+async function assertDirectory(path, generation) {
+  const current = await directoryGeneration(path);
+  if (current.dev !== generation.dev || current.ino !== generation.ino)
+    throw new Error("CLI storage directory generation changed");
+}
+async function bindPublicationStorage(data, signal) {
+  signal.throwIfAborted();
+  assertDirectoryDurability();
+  const requested = resolve(data.storageRoot);
+  try {
+    await mkdir(requested, { mode: 448 });
+  } catch (error) {
+    if (!(error instanceof Error && ("code" in error) && error.code === "EEXIST"))
+      throw error;
+  }
+  await directoryGeneration(requested);
+  const root = await realpath(requested);
+  const generation = await directoryGeneration(root);
+  const files = await createManagedFileBoundary2({
+    root,
+    maxReadBytes: Math.max(data.limits.maxManifestBytes, data.limits.maxCompressedBytes),
+    maxWriteBytes: Math.max(data.limits.maxManifestBytes, data.limits.maxCompressedBytes)
+  });
+  return {
+    root,
+    files,
+    async assertRoot() {
+      await assertDirectory(requested, generation);
+      await assertDirectory(root, generation);
+    }
+  };
+}
+async function directoryNames(path, maxEntries, signal) {
+  const names = [];
+  const directory = await opendir(path);
+  try {
+    for await (const entry of directory) {
+      signal.throwIfAborted();
+      names.push(entry.name);
+      if (names.length > maxEntries)
+        throw new RangeError("CLI publication directory entry cap exceeded");
+    }
+  } finally {
+    await directory.close().catch(() => {
+      return;
+    });
+  }
+  return names.sort();
+}
+async function readPublicationManifest(storage, path, data, signal) {
+  try {
+    const read = await storage.files.read(path, {
+      rejectSymlinks: true,
+      singleLink: true,
+      stable: true,
+      maxBytes: data.limits.maxManifestBytes,
+      signal
+    });
+    return {
+      manifest: CliBuildManifestSchema2.parse(JSON.parse(new TextDecoder().decode(read.bytes))),
+      bytes: read.bytes
+    };
+  } catch (error) {
+    if (error instanceof ManagedFileError2 && error.code === "FILE_NOT_FOUND")
+      return;
+    throw error;
+  }
+}
+function assertPublicationManifest(record, data, exactTargets) {
+  const { manifest } = record;
+  PublicationVersionSchema.parse(manifest.version);
+  if (manifest.name !== data.name || manifest.assets.length === 0 || manifest.assets.length > data.limits.maxTargets)
+    throw new Error("CLI version identity or target count is invalid");
+  const expected = manifest.assets.map((asset) => assetFilename(data.name, asset));
+  if (new Set(expected).size !== expected.length || manifest.assets.some((asset) => !PublicationTargetSchema.safeParse(asset).success || asset.compression !== "gzip"))
+    throw new Error("CLI version targets or compression do not match publisher layout");
+  if (exactTargets) {
+    const requested = data.targets.map((target) => assetFilename(data.name, target)).sort();
+    if (JSON.stringify(requested) !== JSON.stringify([...expected].sort()))
+      throw new Error("CLI publication target set differs from existing version");
+  }
+  for (const asset of manifest.assets) {
+    const file = assetFilename(data.name, asset);
+    const url = new URL(asset.url);
+    const suffix = `/${encodeURIComponent(manifest.version)}/${encodeURIComponent(file)}`;
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || !url.pathname.endsWith(suffix) || url.search || url.hash || exactTargets && asset.url !== assetUrl(data.baseUrl, manifest.version, file))
+      throw new Error("CLI asset URL differs from owned version layout");
+  }
+  return expected;
+}
+async function assertStoredLayout(storage, record, expected, data, signal) {
+  const version = record.manifest.version;
+  const names = await directoryNames(join(storage.root, version), data.limits.maxDirectoryEntries, signal);
+  if (JSON.stringify(names) !== JSON.stringify([...expected, "manifest.json"].sort()))
+    throw new Error("CLI version has unknown or missing files");
+  const saved = await readPublicationManifest(storage, `${version}/manifest.json`, data, signal);
+  if (!saved || !Buffer.from(saved.bytes).equals(Buffer.from(record.bytes)))
+    throw new Error("CLI version manifest differs from publication");
+}
+async function verifyPublicationVersion(storage, record, data, signal, exactTargets) {
+  const { manifest } = record;
+  const expected = assertPublicationManifest(record, data, exactTargets);
+  const directory = join(storage.root, manifest.version);
+  const generation = await directoryGeneration(directory);
+  await assertStoredLayout(storage, record, expected, data, signal);
+  for (const asset of manifest.assets) {
+    const file = assetFilename(data.name, asset);
+    const archived = await storage.files.read(`${manifest.version}/${file}`, {
+      rejectSymlinks: true,
+      singleLink: true,
+      stable: true,
+      maxBytes: data.limits.maxCompressedBytes,
+      signal
+    });
+    await decodeCliAsset(archived.bytes, asset, data.limits.maxAssetBytes, signal);
+  }
+  await assertDirectory(directory, generation);
+}
+async function publicationHistory(storage, data, signal) {
+  const history = [];
+  for (const name of await directoryNames(storage.root, data.limits.maxDirectoryEntries, signal)) {
+    if (!PublicationVersionSchema.safeParse(name).success)
+      continue;
+    const path = join(storage.root, name);
+    const info = await lstat(path);
+    if (!info.isDirectory() || info.isSymbolicLink())
+      continue;
+    let record;
+    try {
+      record = await readPublicationManifest(storage, `${name}/manifest.json`, data, signal);
+    } catch (error) {
+      if (error instanceof SyntaxError || error instanceof z2.ZodError)
+        continue;
+      throw error;
+    }
+    if (!record || record.manifest.name !== data.name || record.manifest.version !== name)
+      continue;
+    await verifyPublicationVersion(storage, record, data, signal, false);
+    history.push({ ...record, directory: path });
+    if (history.length > data.limits.maxStoredVersions)
+      throw new RangeError("CLI publication stored version cap exceeded");
+  }
+  return history;
+}
+async function removePublicationVersion(storage, version, data, signal) {
+  await storage.assertRoot();
+  const generation = await directoryGeneration(version.directory);
+  await assertStoredLayout(storage, version, assertPublicationManifest(version, data, false), data, signal);
+  await assertDirectory(version.directory, generation);
+  await rm(version.directory, { recursive: true });
+  await syncDirectory(storage.root);
+}
+var STAGING_NAME = /^\.publish-[A-Za-z0-9]{6}$/;
+async function reclaimPublicationStaging(storage, signal) {
+  await storage.assertRoot();
+  const stale = [];
+  const directory = await opendir(storage.root);
+  try {
+    for await (const entry of directory) {
+      signal.throwIfAborted();
+      if (STAGING_NAME.test(entry.name) && entry.isDirectory())
+        stale.push(entry.name);
+    }
+  } finally {
+    await directory.close().catch(() => {
+      return;
+    });
+  }
+  for (const name of stale) {
+    signal.throwIfAborted();
+    await rm(join(storage.root, name), { recursive: true });
+  }
+  if (stale.length > 0)
+    await syncDirectory(storage.root);
+  return stale.length;
+}
+
+// src/tools/cli/publication.ts
+var resultSchema = z3.object({
+  outcome: z3.enum(["published", "existing"]),
+  manifest: CliBuildManifestSchema2
+});
+function trustPublication(manifest, options) {
+  const verdict = verifyCliManifest2(manifest, manifest.signature, options.trust);
+  if (!cliSignatureAccepted2(verdict))
+    throw new Error(`CLI publication manifest signature ${verdict}`);
+  if (options.signing && !manifest.signature)
+    throw new Error("CLI publication requires a signed manifest");
+}
+function sameManifest(left, right) {
+  return left === undefined ? right === undefined : right !== undefined && Buffer.from(left.bytes).equals(Buffer.from(right.bytes));
+}
+async function admission(options, data, phase, signal) {
+  signal.throwIfAborted();
+  await waitForPublication(Promise.resolve().then(() => {
+    signal.throwIfAborted();
+    return options.admit({
+      phase,
+      identity: Object.freeze({
+        name: data.name,
+        version: data.version,
+        commit: data.commit
+      }),
+      signal
+    });
+  }), signal);
+}
+async function unchanged(storage, prior, data, lock, signal) {
+  signal.throwIfAborted();
+  await lock.assertHeld();
+  await storage.assertRoot();
+  if (!sameManifest(prior, await readPublicationManifest(storage, "manifest.json", data, signal)))
+    throw new Error("CLI public manifest changed during publication");
+}
+function newest(versions) {
+  return [...versions].sort((a, b) => compareCliVersions2(b.manifest.version, a.manifest.version) ?? 0);
+}
+async function retainVersions(storage, history, keep, count, data, lock, signal) {
+  const retained = newest(history).filter((item) => !keep.has(item.manifest.version));
+  const spare = Math.max(0, count - keep.size);
+  const removed = new Set(retained.slice(spare));
+  for (const version of removed) {
+    await lock.assertHeld();
+    await removePublicationVersion(storage, version, data, signal);
+  }
+  return history.filter((item) => !removed.has(item));
+}
+async function promote(storage, record, prior, data, options, lock, signal) {
+  await admission(options, data, "promote", signal);
+  trustPublication(record.manifest, options);
+  await unchanged(storage, prior, data, lock, signal);
+  const names = await directoryNames(storage.root, data.limits.maxDirectoryEntries, signal);
+  if (names.length + 1 > data.limits.maxDirectoryEntries)
+    throw new RangeError("CLI publication directory entry cap leaves no pointer space");
+  signal.throwIfAborted();
+  await writeFileAtomic2(join2(storage.root, "manifest.json"), record.bytes, {
+    mode: 420,
+    durability: "directory"
+  });
+  const current = await readPublicationManifest(storage, "manifest.json", data, signal);
+  if (!sameManifest(record, current))
+    throw new Error("CLI public manifest readback differs after promotion");
+}
+async function buildVersion(storage, data, options, lock, prior, signal) {
+  const names = await directoryNames(storage.root, data.limits.maxDirectoryEntries, signal);
+  if (names.length + 2 > data.limits.maxDirectoryEntries)
+    throw new RangeError("CLI publication directory entry cap leaves no commit space");
+  const staged = await mkdtemp(join2(storage.root, ".publish-"));
+  const generation = await directoryGeneration(staged);
+  let committed = false;
+  try {
+    const files = await createManagedFileBoundary2({
+      root: staged,
+      maxWriteBytes: Math.max(data.limits.maxCompressedBytes, data.limits.maxManifestBytes)
+    });
+    const stamp = Object.freeze({
+      version: data.version,
+      commit: data.commit,
+      builtAt: new Date().toISOString()
+    });
+    const assets = [];
+    for (const target of data.targets) {
+      await admission(options, data, "build", signal);
+      signal.throwIfAborted();
+      const source = await waitForPublication(Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return options.build({ target: Object.freeze({ ...target }), stamp, signal });
+      }), signal);
+      if (!(source instanceof Uint8Array) && !(source instanceof ReadableStream))
+        throw new TypeError("CLI builder must return bytes or a stream");
+      const bytes = await collectCliBytes(source, data.limits.maxAssetBytes, signal);
+      if (bytes.byteLength === 0)
+        throw new Error("CLI asset must not be empty");
+      const archived = await gzipCliAsset(bytes, data.limits.maxCompressedBytes, signal);
+      await lock.assertHeld();
+      await storage.assertRoot();
+      await assertDirectory(staged, generation);
+      const file = assetFilename(data.name, target);
+      await files.write(file, archived, { durable: true, signal });
+      assets.push({
+        ...target,
+        compression: "gzip",
+        size: bytes.byteLength,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        url: assetUrl(data.baseUrl, data.version, file)
+      });
+    }
+    const manifest = CliBuildManifestSchema2.parse({ name: data.name, ...stamp, assets });
+    if (options.signing)
+      manifest.signature = signCliManifest2(manifest, options.signing);
+    trustPublication(manifest, options);
+    const bytes = new TextEncoder().encode(`${JSON.stringify(manifest)}
+`);
+    if (bytes.byteLength > data.limits.maxManifestBytes)
+      throw new RangeError("CLI publication manifest byte cap exceeded");
+    await assertDirectory(staged, generation);
+    await files.write("manifest.json", bytes, {
+      durable: true,
+      maxBytes: data.limits.maxManifestBytes,
+      signal
+    });
+    await admission(options, data, "commit", signal);
+    await unchanged(storage, prior, data, lock, signal);
+    await assertDirectory(staged, generation);
+    try {
+      await lstat2(join2(storage.root, data.version));
+      throw new Error("CLI version directory already exists");
+    } catch (error) {
+      if (!(error instanceof Error && ("code" in error) && error.code === "ENOENT"))
+        throw error;
+    }
+    signal.throwIfAborted();
+    await rename(staged, join2(storage.root, data.version));
+    committed = true;
+    await syncDirectory(storage.root);
+    return { manifest, bytes };
+  } catch (error) {
+    if (!committed) {
+      try {
+        await storage.assertRoot();
+        await assertDirectory(staged, generation);
+        await rm2(staged, { recursive: true });
+      } catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], "CLI publication failed and safe staging cleanup was refused");
+      }
+    }
+    if (committed && !(error instanceof AtomicFilePublicationError2))
+      throw new Error("CLI version committed; publication outcome must be checked", {
+        cause: error
+      });
+    throw error;
+  }
+}
+async function publishLocked(storage, data, options, lock, signal) {
+  await lock.assertHeld();
+  await admission(options, data, "prepare", signal);
+  await reclaimPublicationStaging(storage, signal);
+  const prior = await readPublicationManifest(storage, "manifest.json", data, signal);
+  if (prior && prior.manifest.name !== data.name)
+    throw new Error("CLI public manifest belongs to another CLI");
+  const history = await publicationHistory(storage, data, signal);
+  const candidate = {
+    name: data.name,
+    version: data.version,
+    commit: data.commit,
+    builtAt: new Date().toISOString(),
+    assets: []
+  };
+  assertCliPublishable2([...prior ? [prior.manifest] : [], ...history.map((item) => item.manifest)], candidate);
+  if (prior) {
+    const pointed = history.find((item) => item.manifest.version === prior.manifest.version);
+    if (!pointed || !sameManifest(prior, pointed))
+      throw new Error("CLI public manifest differs from its stored version");
+    assertPublicationManifest(prior, data, prior.manifest.version === data.version);
+    trustPublication(prior.manifest, options);
+    const order = compareCliVersions2(data.version, prior.manifest.version) ?? -1;
+    if (order < 0 || order === 0 && data.version !== prior.manifest.version)
+      throw new Error("CLI publication downgrade or non-advancing version refused");
+    if (prior.manifest.version === data.version) {
+      await admission(options, data, "promote", signal);
+      await unchanged(storage, prior, data, lock, signal);
+      return { outcome: "existing", manifest: prior.manifest };
+    }
+  }
+  let record = history.find((item) => item.manifest.version === data.version);
+  let stored = history;
+  if (record) {
+    assertPublicationManifest(record, data, true);
+    trustPublication(record.manifest, options);
+  } else {
+    const protect = new Set(prior ? [prior.manifest.version] : []);
+    const previous = newest(history).find((item) => prior && (compareCliVersions2(item.manifest.version, prior.manifest.version) ?? 0) < 0);
+    if (previous)
+      protect.add(previous.manifest.version);
+    stored = await retainVersions(storage, history, protect, data.limits.maxStoredVersions - 1, data, lock, signal);
+    record = {
+      ...await buildVersion(storage, data, options, lock, prior, signal),
+      directory: join2(storage.root, data.version)
+    };
+    await verifyPublicationVersion(storage, record, data, signal, true);
+    stored = [...stored, record];
+  }
+  try {
+    await promote(storage, record, prior, data, options, lock, signal);
+    if (stored.length > data.limits.maxStoredVersions)
+      throw new RangeError("CLI publication stored version cap exceeded");
+    await retainVersions(storage, stored, new Set([data.version, ...prior ? [prior.manifest.version] : []]), data.retention, data, lock, signal);
+  } catch (error) {
+    if (error instanceof AtomicFilePublicationError2)
+      throw error;
+    throw new Error("CLI version committed; publication outcome must be checked", {
+      cause: error
+    });
+  }
+  return { outcome: "published", manifest: record.manifest };
+}
+async function publishCli(options) {
+  const data = publicationData(options);
+  return withPublicationDeadline(data.limits.timeoutMs, options.signal, async (signal) => {
+    const storage = await bindPublicationStorage(data, signal);
+    return withExclusiveLock2(join2(storage.root, ".publication.lock"), (lock) => publishLocked(storage, data, options, lock, signal), { timeoutMs: data.limits.lockTimeoutMs, signal, label: "CLI publication" });
+  });
+}
+export {
+  publishCli
+};

package/dist/entrypoints/cli.d.ts

@@ -28,13 +28,12 @@ export { type CliInstallerConfig, renderCliInstaller, } from '../tools/cli/insta
 export { assertCliPublishable, type CliBuildAsset, CliBuildAssetSchema, type CliBuildManifest, CliBuildManifestSchema, type CliBuildStamp, CliBuildStampSchema, type CliBuildTarget, CliBuildTargetSchema, currentCliBuildTarget, formatCliBuildStamp, selectCliBuildAsset, } from '../tools/cli/manifest.js';
 export type { CliPresentationPolicyConfig } from '../tools/cli/policy.js';
 export { CliProfileError, type CliProfileStore, type CliProfileStoreConfig, createCliProfileStore, type ResolvedCliProfile, } from '../tools/cli/profile.js';
-export { type CliPublicationOptions, type CliPublicationPhase, type CliPublicationResult, publishCli, } from '../tools/cli/publication.js';
 export { type CliBuildSignature, CliBuildSignatureSchema, type CliSignatureVerdict, type CliSigningKey, type CliTrustRoot, cliManifestSigningPayload, cliSignatureAccepted, signCliManifest, verifyCliManifest, } from '../tools/cli/signature.js';
 export { type CliBatchCommandConfig, type CliStreamAnswer, type CliStreamCommandConfig, type CliStreamHooks, defineCliBatchCommand, defineCliStreamCommand, runCliStream, } from '../tools/cli/stream.js';
 export { type AppliedCliUpdate, applyCliUpdate, type CliRollbackConfig, type CliUpdateApplyConfig, type CliUpdateCheck, type CliUpdateCheckConfig, checkCliUpdate, compareCliVersions, type RolledBackCliUpdate, rollbackCliUpdate, } from '../tools/cli/update.js';
 export { type CliViewOutput, renderCliView } from '../tools/cli/view.js';
 export { type CliWaitConfig, type PollParams, pollUntilDone } from '../tools/cli/wait.js';
-export type { RuntimeToolDefinitionWithoutOutput, RuntimeToolExecution, RuntimeToolExecutionWithOutput, } from '../tools/runtime-tool-execution.js';
+export type { RuntimeToolDefinition, RuntimeToolDefinitionWithOutput, RuntimeToolDefinitionWithoutOutput, } from '../tools/runtime-tool-declaration.js';
 /**
  * The second half of `parseCliArgs`. The parser leaves array and object values
  * as strings on purpose, because `executeToolMethod` runs this pass next; a

package/dist/entrypoints/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/entrypoints/cli.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/entrypoints/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,uBAAuB,EACvB,KAAK,aAAa,EAClB,YAAY,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC1E,YAAY,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,8BAA8B,EACnC,KAAK,iCAAiC,EACtC,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,mBAAmB,EACnB,SAAS,EACT,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,UAAU,EACf,WAAW,EACX,kBAAkB,EAClB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,UAAU,GACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,kBAAkB,EACvB,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,oBAAoB,EACpB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,cAAc,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EACL,eAAe,EACf,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,yBAAyB,EACzB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,GACb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,gBAAgB,EACrB,cAAc,EACd,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,cAAc,EACd,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvF,YAAY,EACV,qBAAqB,EACrB,+BAA+B,EAC/B,kCAAkC,GACnC,MAAM,mCAAmC,CAAC;AAC3C;;;;;;GAMG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC"}