@iowarp/clio-coder 0.4.5 → 0.4.7

package/dist/library-QAPAO23R.js

@@ -0,0 +1,306 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  finalizeObservation
+} from "./chunk-IZYTT3CD.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-DLIYANB7.js";
+import "./chunk-24TOGHPO.js";
+import "./chunk-BO4XV5VX.js";
+import "./chunk-B6UM3OZC.js";
+import {
+  byteLength
+} from "./chunk-MYI32N4R.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-HOX4YZ2K.js";
+import "./chunk-2O2LVQQK.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import {
+  ToolNames
+} from "./chunk-WLHX3MM5.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/context/library.ts
+init_esm_shims();
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 50;
+var MAX_PROVIDES = 12;
+var MAX_DESCRIPTION = 160;
+var MAX_REASON = 200;
+var MAX_DIAGNOSTICS = 3;
+var MAX_DIAGNOSTIC = 160;
+var MAX_ORIGIN_VALUE = 240;
+var MAX_REQUIRES = 8;
+var MAX_INVOCATION = 200;
+var MAX_ECHO = 120;
+var WORKER_UNAVAILABLE = 'context: scope="library" is unavailable in this run; a worker has no library projection of its own and cannot install or activate anything. Work from the resources your assignment already bound, and record the gap with the limitation tool if it blocks the task.';
+var OPERATOR_NOTE = "Read-only catalog: you cannot install or activate from here. Suggest /library to the operator for packages and /skill <name> for a skill. A hint row is a catalog claim, not a loaded recipe, and cannot be invoked.";
+var NOTE_SKILLS_OFF = "Skill discovery is off for this run, so no skill rows are listed.";
+var NOTE_INVENTORY_CAPPED = "The inventory returned as many records as it carries, so this listing and its install evidence are incomplete; narrow with kind or query.";
+var NOTE_AMBIGUOUS_REF = "This ref matched several records; select one by the key on its row.";
+var NOTE_NO_MATCH = "Nothing matched; drop ref or query to list the catalog.";
+var NOTE_NO_BUDGET = "The remaining observation budget cannot carry a row this turn; continue in a follow-up turn.";
+var ALL_NOTE_CLAUSES = [
+  OPERATOR_NOTE,
+  NOTE_SKILLS_OFF,
+  NOTE_INVENTORY_CAPPED,
+  NOTE_AMBIGUOUS_REF,
+  NOTE_NO_MATCH,
+  NOTE_NO_BUDGET
+].join(" ");
+function clampLimit(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_LIMIT;
+  return Math.max(1, Math.min(MAX_LIMIT, Math.floor(value)));
+}
+function clampOffset(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+  return Math.floor(value);
+}
+function bound(value, max) {
+  return value.length <= max ? value : `${value.slice(0, max - 1)}\u2026`;
+}
+function boundDiagnostics(diagnostics) {
+  return diagnostics.slice(0, MAX_DIAGNOSTICS).map((entry) => bound(entry, MAX_DIAGNOSTIC));
+}
+function boundOrigin(origin) {
+  const out = {};
+  for (const [key, value] of Object.entries(origin)) {
+    out[key] = typeof value === "string" ? bound(value, MAX_ORIGIN_VALUE) : value;
+  }
+  return out;
+}
+function projectResource(resource, ambiguous) {
+  return {
+    row: "resource",
+    kind: resource.kind,
+    name: resource.name,
+    // The stable inventory key is what disambiguates two same-named
+    // resources from different owners; it is spent only when there are two.
+    ...ambiguous ? { key: resource.key } : {},
+    description: bound(resource.description, MAX_DESCRIPTION),
+    owner: resource.owner ? resource.owner.ref : resource.source.class,
+    scope: resource.source.scope,
+    origin: boundOrigin(resource.origin),
+    ...resource.format !== void 0 ? { format: resource.format } : {},
+    ...resource.availability !== "available" ? { availability: resource.availability } : {},
+    ...resource.reason !== void 0 ? { reason: bound(resource.reason, MAX_REASON) } : {},
+    ...resource.invocation !== void 0 ? { invocation: bound(resource.invocation, MAX_INVOCATION) } : {},
+    ...resource.diagnostics.length > 0 ? { diagnostics: boundDiagnostics(resource.diagnostics) } : {}
+  };
+}
+function identityOnly(row) {
+  return {
+    row: row.row,
+    kind: row.kind,
+    name: row.name,
+    ...row.key !== void 0 ? { key: row.key } : {},
+    ...row.ref !== void 0 ? { ref: row.ref } : {},
+    ...row.owner !== void 0 ? { owner: row.owner } : {},
+    truncatedRecord: true
+  };
+}
+function projectHint(kind, name, description, owner, copiesCapped) {
+  const installed = owner.copies.map((copy) => ({ scope: copy.scope, state: copy.state }));
+  return {
+    row: "hint",
+    kind,
+    name,
+    ...description !== void 0 ? { description: bound(description, MAX_DESCRIPTION) } : {},
+    owner: owner.ref,
+    ownerInstalled: installed,
+    member: installed.length === 0 && !copiesCapped ? "not-installed" : "unknown",
+    origin: boundOrigin(owner.origin),
+    ...owner.format !== void 0 ? { format: owner.format } : {}
+  };
+}
+function projectPackage(record, copiesCapped) {
+  const provides = record.provides ?? [];
+  const shownProvides = provides.slice(0, MAX_PROVIDES);
+  const installed = record.copies.map((copy) => ({ scope: copy.scope, state: copy.state }));
+  return {
+    row: "package",
+    kind: record.kind,
+    name: record.name,
+    ref: record.ref,
+    description: bound(record.description, MAX_DESCRIPTION),
+    ...record.version !== void 0 ? { version: record.version } : {},
+    origin: boundOrigin(record.origin),
+    ...record.format !== void 0 ? { format: record.format } : {},
+    installed,
+    // An empty list under a capped copy read is silence, not absence.
+    ...installed.length === 0 && copiesCapped ? { installedUnknown: true } : {},
+    ...record.provides === void 0 ? { provides: "unknown until inspection" } : {
+      provides: shownProvides.map((hint) => `${hint.kind}:${hint.name}`),
+      ...provides.length > shownProvides.length ? { providesOmitted: provides.length - shownProvides.length } : {}
+    },
+    ...record.requires !== void 0 ? {
+      requires: record.requires.slice(0, MAX_REQUIRES),
+      ...record.requires.length > MAX_REQUIRES ? { requiresOmitted: record.requires.length - MAX_REQUIRES } : {}
+    } : {},
+    ...record.refusal !== void 0 ? { refusal: bound(record.refusal, MAX_REASON) } : {}
+  };
+}
+function fitPage(candidate, capBytes, envelopeBytes) {
+  const budget = capBytes - envelopeBytes;
+  let used = 0;
+  const page = [];
+  for (const row of candidate) {
+    const cost = byteLength(JSON.stringify(row)) + 1;
+    if (used + cost <= budget) {
+      used += cost;
+      page.push(row);
+      continue;
+    }
+    if (page.length === 0) {
+      const identity = identityOnly(row);
+      if (byteLength(JSON.stringify(identity)) + 1 <= budget) page.push(identity);
+    }
+    break;
+  }
+  return page;
+}
+function ambiguousNames(resources) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const resource of resources) {
+    const id = `${resource.kind}:${resource.name}`;
+    seen.set(id, (seen.get(id) ?? 0) + 1);
+  }
+  return new Set([...seen].filter(([, count]) => count > 1).map(([id]) => id));
+}
+function hintSelection(ref, inventory) {
+  if (ref.length === 0) return { mode: "all" };
+  if (ref.includes("@")) return { mode: "none" };
+  const owner = inventory.packages.find((record) => record.ref === ref);
+  if (owner) return { mode: "owner", ref: owner.ref };
+  const colon = ref.indexOf(":");
+  return { mode: "name", name: colon >= 0 ? ref.slice(colon + 1) : ref };
+}
+function hintRows(inventory, resources, kind, query, ref, copiesCapped) {
+  if (kind === "plugin") return [];
+  const selection = hintSelection(ref, inventory);
+  if (selection.mode === "none") return [];
+  const actual = new Set(
+    resources.filter((resource) => resource.owner).map((resource) => `${resource.owner?.ref}|${resource.kind}|${resource.name}`)
+  );
+  const needle = query.toLowerCase();
+  const rows = [];
+  for (const record of inventory.packages) {
+    if (selection.mode === "owner" && record.ref !== selection.ref) continue;
+    for (const hint of record.provides ?? []) {
+      if (kind !== void 0 && hint.kind !== kind) continue;
+      if (selection.mode === "name" && hint.name !== selection.name) continue;
+      if (actual.has(`${record.ref}|${hint.kind}|${hint.name}`)) continue;
+      if (needle.length > 0 && !`${hint.kind}:${hint.name} ${hint.description ?? ""}`.toLowerCase().includes(needle))
+        continue;
+      rows.push(projectHint(hint.kind, hint.name, hint.description, record, copiesCapped));
+    }
+  }
+  return rows;
+}
+async function runLibraryScope(deps, args, reservation, options) {
+  if (deps.skillMarketplace === false) {
+    return { kind: "error", message: WORKER_UNAVAILABLE };
+  }
+  const kind = typeof args.kind === "string" ? args.kind : void 0;
+  const query = typeof args.query === "string" ? args.query.trim() : "";
+  const ref = typeof args.ref === "string" ? args.ref.trim() : "";
+  const limit = clampLimit(args.limit);
+  const offset = clampOffset(args.offset);
+  const skillsDisabled = deps.skillLoaderOptions?.disableDiscovery === true;
+  const wantsResources = kind !== "plugin" && !(kind === "skill" && skillsDisabled);
+  let inventory;
+  try {
+    inventory = await loadInventory({
+      cwd: deps.getCwd(),
+      audience: "model",
+      include: { packages: true, copies: false, resources: wantsResources },
+      ...kind !== void 0 ? { kinds: [kind] } : {},
+      ...query.length > 0 ? { query } : {},
+      ...ref.length > 0 ? { ref } : {},
+      ...deps.skillLoaderOptions?.trustProjectCompatRoots !== void 0 ? { trustProjectCompatRoots: deps.skillLoaderOptions.trustProjectCompatRoots } : {}
+    });
+  } catch (err) {
+    return {
+      kind: "error",
+      message: `context: library inventory unavailable: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const resources = wantsResources ? inventory.resources.filter((resource) => !(skillsDisabled && resource.kind === "skill")) : [];
+  const ambiguous = ambiguousNames(resources);
+  const copiesCapped = inventory.truncated.copies;
+  const rows = [
+    ...resources.map((resource) => projectResource(resource, ambiguous.has(`${resource.kind}:${resource.name}`))),
+    ...hintRows(inventory, resources, kind, query, ref, copiesCapped),
+    ...inventory.packages.map((record) => projectPackage(record, copiesCapped))
+  ];
+  const total = rows.length;
+  const inventoryCapped = inventory.truncated.resources || inventory.truncated.packages || copiesCapped;
+  const diagnostics = boundDiagnostics(inventory.diagnostics);
+  const header = {
+    scope: "library",
+    ...kind !== void 0 ? { kind } : {},
+    ...query.length > 0 ? { query: bound(query, MAX_ECHO) } : {},
+    ...ref.length > 0 ? { ref: bound(ref, MAX_ECHO) } : {},
+    total,
+    ...inventoryCapped ? { totalIsLowerBound: true } : {},
+    offset,
+    ...diagnostics.length > 0 ? { diagnostics } : {}
+  };
+  const envelopeBytes = byteLength(
+    JSON.stringify({ ...header, shown: total, nextOffset: total, rows: [], note: ALL_NOTE_CLAUSES })
+  );
+  const page = fitPage(rows.slice(offset, offset + limit), reservation.callCapBytes, envelopeBytes);
+  const exhaustedPage = page.length === 0 && total > offset;
+  const nextOffset = !exhaustedPage && offset + page.length < total ? offset + page.length : void 0;
+  const payload = {
+    ...header,
+    shown: page.length,
+    ...nextOffset !== void 0 ? { nextOffset } : {},
+    rows: page,
+    note: [
+      OPERATOR_NOTE,
+      ...skillsDisabled ? [NOTE_SKILLS_OFF] : [],
+      ...inventoryCapped ? [NOTE_INVENTORY_CAPPED] : [],
+      ...ref.length > 0 && total > 1 ? [NOTE_AMBIGUOUS_REF] : [],
+      ...total === 0 && (ref.length > 0 || query.length > 0) ? [NOTE_NO_MATCH] : [],
+      ...exhaustedPage ? [NOTE_NO_BUDGET] : []
+    ].join(" ")
+  };
+  return finalizeObservation({
+    tool: ToolNames.Context,
+    unit: "entries",
+    format: "json",
+    output: JSON.stringify(payload),
+    shownCount: page.length,
+    totalCount: total,
+    truncated: nextOffset !== void 0 || inventoryCapped || exhaustedPage,
+    ...nextOffset !== void 0 ? { next: `offset=${nextOffset}` } : {},
+    reservation,
+    ...options ? { options } : {}
+  });
+}
+async function loadInventory(options) {
+  const { readLibraryInventory } = await import("./library-inventory-JT6HWITQ.js");
+  return readLibraryInventory(options);
+}
+export {
+  runLibraryScope
+};
+//# sourceMappingURL=library-QAPAO23R.js.map

package/dist/library-import-5Y6MAS3R.js

@@ -0,0 +1,183 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  applyLibraryImport,
+  libraryImportPlanSummary,
+  planLibraryImport,
+  releaseLibraryImport,
+  renderLibraryImportPlan
+} from "./chunk-CP3HIR5H.js";
+import "./chunk-4N2RZ4TO.js";
+import "./chunk-WURGVOZJ.js";
+import "./chunk-4UHVS5T7.js";
+import {
+  printError
+} from "./chunk-3T4DXWP6.js";
+import "./chunk-6CB2IL4N.js";
+import "./chunk-6TAATXXH.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-WB7POC6M.js";
+import "./chunk-MZNWZUJM.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-RXFPB32E.js";
+import "./chunk-KKEYGFX4.js";
+import "./chunk-YKRJTYNP.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-34XHRVKG.js";
+import "./chunk-XW2UZICE.js";
+import {
+  readSettings
+} from "./chunk-4QKAITQT.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-HOX4YZ2K.js";
+import "./chunk-2O2LVQQK.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-WLHX3MM5.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/library-import.ts
+init_esm_shims();
+import { createInterface } from "node:readline/promises";
+var HELP = `clio-coder library import <path|github-tree-url> [--user|--project] [--format claude|codex] [--dry-run] [--json] [--yes]
+
+Review and import a plugin package from a local directory or a GitHub tree URL
+(https://github.com/owner/repo/tree/ref/path). A portable root plugin.json is
+imported as-is (data only). A .claude-plugin/plugin.json or .codex-plugin/plugin.json
+package is normalized into a portable Clio package: skills keep their text and
+frontmatter names, command markdown becomes prompt recipes, Claude agents become
+read-only Clio agents. Hooks, MCP, LSP, scripts and host settings are reported and
+never activated. Imported packages keep foreign trust; --format disambiguates when
+both hidden manifests exist. Source files are never changed.
+`;
+function parse(args) {
+  const out = { dryRun: false, json: false, yes: false, help: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg === "--help" || arg === "-h") out.help = true;
+    else if (arg === "--json") out.json = true;
+    else if (arg === "--yes") out.yes = true;
+    else if (arg === "--dry-run") out.dryRun = true;
+    else if (arg === "--user" || arg === "--project") {
+      const scope = arg === "--user" ? "user" : "project";
+      if (out.scope && out.scope !== scope) throw new Error("--user and --project are mutually exclusive");
+      out.scope = scope;
+    } else if (arg === "--format") {
+      const value = args[++i];
+      const format = value === "claude" || value === "claude-code" ? "claude-code" : value === "codex" ? "codex" : void 0;
+      if (!format) throw new Error("--format requires claude or codex");
+      out.format = format;
+    } else if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    else if (out.source) throw new Error("library import takes exactly one path or GitHub tree URL");
+    else out.source = arg;
+  }
+  return out;
+}
+async function runLibraryImport(args) {
+  let parsed;
+  try {
+    parsed = parse(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (parsed.help || !parsed.source) {
+    process.stdout.write(HELP);
+    return parsed.help ? 0 : 2;
+  }
+  const emit = (value) => {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+  };
+  let plan;
+  try {
+    plan = planLibraryImport(parsed.source, {
+      cwd: process.cwd(),
+      ...parsed.scope ? { scope: parsed.scope } : {},
+      ...parsed.format ? { format: parsed.format } : {}
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (parsed.json) emit({ ok: false, error: message });
+    else printError(message);
+    return 1;
+  }
+  try {
+    if (!parsed.json) process.stdout.write(`${renderLibraryImportPlan(plan)}
+`);
+    if (parsed.dryRun || plan.action !== "install") {
+      if (parsed.json) emit({ ok: plan.action === "install", confirmed: false, plan: libraryImportPlanSummary(plan) });
+      return plan.action === "install" ? 0 : 1;
+    }
+    let yes = parsed.yes;
+    if (!yes && !parsed.json && process.stdin.isTTY && process.stdout.isTTY) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        yes = (await rl.question("Import this plan? [y/N] ")).trim().toLowerCase() === "y";
+      } finally {
+        rl.close();
+      }
+    }
+    let trustProjectImports;
+    try {
+      trustProjectImports = readSettings().integrations.projectResources.trustProjectImports === true;
+    } catch {
+      trustProjectImports = void 0;
+    }
+    const summary = libraryImportPlanSummary(plan);
+    const result = applyLibraryImport(plan, yes, trustProjectImports === void 0 ? {} : { trustProjectImports });
+    plan = { ...plan, cleanup: () => {
+    } };
+    if (parsed.json) emit({ ok: result.published, confirmed: yes, plan: summary, result });
+    else {
+      if (result.installed) process.stdout.write(`Installed ${result.installed} at ${result.destination}
+`);
+      if (result.validation) {
+        const count = result.validation.validation.resources.length;
+        process.stdout.write(
+          `${result.validation.valid ? "Validated" : "Validation failed for"} ${count} installed resource${count === 1 ? "" : "s"}
+`
+        );
+        for (const diagnostic of result.validation.validation.diagnostics)
+          process.stderr.write(
+            `  [${diagnostic.code}] ${diagnostic.message}${diagnostic.path ? ` (${diagnostic.path})` : ""}
+`
+          );
+      }
+      process.stdout.write(
+        `Trust: foreign; trust gate ${result.admission.gate} is ${result.admission.gateEnabled === "unknown" ? "unread" : result.admission.gateEnabled ? "enabled" : "disabled"}; runtime availability is reported by the library inventory
+`
+      );
+      for (const diagnostic of result.diagnostics) process.stderr.write(`${diagnostic}
+`);
+    }
+    return result.published && (result.validation?.valid ?? true) && result.diagnostics.length === 0 ? 0 : 1;
+  } finally {
+    releaseLibraryImport(plan);
+  }
+}
+export {
+  runLibraryImport
+};
+//# sourceMappingURL=library-import-5Y6MAS3R.js.map

package/dist/library-inventory-JT6HWITQ.js

@@ -0,0 +1,56 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  LIBRARY_INVENTORY_LIMITS,
+  classifyLibraryOrigin,
+  inspectLibraryCopy,
+  libraryCopyState,
+  libraryResourceKey,
+  parseLibraryResourceKey,
+  readLibraryInventory
+} from "./chunk-UWD3JD5X.js";
+import "./chunk-4UHVS5T7.js";
+import "./chunk-WB7POC6M.js";
+import "./chunk-MZNWZUJM.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-RXFPB32E.js";
+import "./chunk-KKEYGFX4.js";
+import "./chunk-YKRJTYNP.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-34XHRVKG.js";
+import "./chunk-XW2UZICE.js";
+import "./chunk-4QKAITQT.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-HOX4YZ2K.js";
+import "./chunk-2O2LVQQK.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-WLHX3MM5.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ECBHH7LU.js";
+export {
+  LIBRARY_INVENTORY_LIMITS,
+  classifyLibraryOrigin,
+  inspectLibraryCopy,
+  libraryCopyState,
+  libraryResourceKey,
+  parseLibraryResourceKey,
+  readLibraryInventory
+};
+//# sourceMappingURL=library-inventory-JT6HWITQ.js.map

package/dist/library-validation-EQUH25DC.js

@@ -0,0 +1,42 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  validateLibraryPackage
+} from "./chunk-WB7POC6M.js";
+import "./chunk-MZNWZUJM.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-RXFPB32E.js";
+import "./chunk-KKEYGFX4.js";
+import "./chunk-YKRJTYNP.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-34XHRVKG.js";
+import "./chunk-XW2UZICE.js";
+import "./chunk-4QKAITQT.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-HOX4YZ2K.js";
+import "./chunk-2O2LVQQK.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-WLHX3MM5.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ECBHH7LU.js";
+export {
+  validateLibraryPackage
+};
+//# sourceMappingURL=library-validation-EQUH25DC.js.map