@skaile/workspaces 0.26.0 → 0.28.1

package/dist/{chunk-RTAIGPTF.js → chunk-MIH45XPY.js}

@@ -1,12 +1,11 @@
 import { readManifestSourceConfig, discoverAssetsInTree } from './chunk-JIQLLZ65.js';
+import { installFromManifest } from './chunk-Z3XXKR5E.js';
 import { parseAssetRef } from './chunk-IEJ5IOC3.js';
 import { PresetManifestSchema } from './chunk-QDJKE557.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import * as crypto from 'crypto';
-import { createHash } from 'crypto';
 import * as fs11 from 'fs';
 import * as path4 from 'path';
-import { resolve, join, sep, dirname, isAbsolute } from 'path';
 import { eq, like, and } from 'drizzle-orm';
 import * as z2 from 'zod';
 import * as os from 'os';
@@ -15,7 +14,6 @@ import { createClient } from '@libsql/client';
 import { drizzle } from 'drizzle-orm/libsql';
 import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
 import { spawnSync } from 'child_process';
-import { rm, mkdir, writeFile } from 'fs/promises';
 
 // library/src/library.ts
 var KNOWN_ASSET_KINDS = [
@@ -52,25 +50,25 @@ var InstanceNotFoundError = class extends LibraryError {
     this.name = "InstanceNotFoundError";
   }
 };
-var SubscriptionNotFoundError = class extends LibraryError {
+var AssignmentNotFoundError = class extends LibraryError {
   constructor(id) {
-    super(`Subscription not found: ${id}`, "SUBSCRIPTION_NOT_FOUND");
-    this.name = "SubscriptionNotFoundError";
+    super(`Assignment not found: ${id}`, "ASSIGNMENT_NOT_FOUND");
+    this.name = "AssignmentNotFoundError";
   }
 };
-var DuplicateSubscriptionError = class extends LibraryError {
+var DuplicateAssignmentError = class extends LibraryError {
   constructor(workspaceId, instanceId) {
     super(
-      `Workspace "${workspaceId}" already subscribes to instance "${instanceId}"`,
-      "DUPLICATE_SUBSCRIPTION"
+      `Workspace "${workspaceId}" already has instance "${instanceId}" assigned`,
+      "DUPLICATE_ASSIGNMENT"
     );
-    this.name = "DuplicateSubscriptionError";
+    this.name = "DuplicateAssignmentError";
   }
 };
 var InstanceHasConsumersError = class extends LibraryError {
   constructor(instanceId, count) {
     super(
-      `Instance "${instanceId}" has ${count} active subscription(s). Use { cascade: true } to force delete.`,
+      `Instance "${instanceId}" has ${count} active assignment(s). Use { cascade: true } to force delete.`,
       "INSTANCE_HAS_CONSUMERS"
     );
     this.name = "InstanceHasConsumersError";
@@ -101,7 +99,7 @@ var CatalogConfigSchema = z2.object({
 var LibraryConfigSchema = z2.object({
   /** Library storage directory. Default: ~/.skaile/libraries */
   dir: z2.string().optional(),
-  /** Default pin policy for new instances/subscriptions. */
+  /** Default pin policy for new instances/assignments. */
   pin_policy: z2.enum(PIN_POLICIES).optional()
 });
 var SkaileConfigSchema = z2.object({
@@ -200,9 +198,9 @@ function saveConfig(filePath, config) {
 var schema_exports = {};
 __export(schema_exports, {
   assetDefinitions: () => assetDefinitions,
+  assignments: () => assignments,
   instances: () => instances,
-  libraries: () => libraries,
-  subscriptions: () => subscriptions
+  libraries: () => libraries
 });
 var libraries = sqliteTable("libraries", {
   /** UUID primary key. */
@@ -258,12 +256,12 @@ var instances = sqliteTable("instances", {
   createdBy: text("created_by"),
   sourceCommitSha: text("source_commit_sha")
 });
-var subscriptions = sqliteTable("subscriptions", {
+var assignments = sqliteTable("assignments", {
   id: text("id").primaryKey(),
   workspaceId: text("workspace_id").notNull(),
   instanceId: text("instance_id").notNull(),
   pinPolicy: text("pin_policy").notNull(),
-  subscribedAt: text("subscribed_at").notNull()
+  assignedAt: text("assigned_at").notNull()
 });
 var SKAILE_HOME_ENV = "SKAILE_HOME";
 function getSidecarRoot() {
@@ -419,16 +417,16 @@ CREATE TABLE IF NOT EXISTS instances (
 );
 CREATE INDEX IF NOT EXISTS idx_instances_def_ref ON instances(def_ref);
 
-CREATE TABLE IF NOT EXISTS subscriptions (
+CREATE TABLE IF NOT EXISTS assignments (
   id             TEXT PRIMARY KEY,
   workspace_id   TEXT NOT NULL,
   instance_id    TEXT NOT NULL REFERENCES instances(id) ON DELETE CASCADE,
   pin_policy     TEXT NOT NULL,
-  subscribed_at  TEXT NOT NULL
+  assigned_at    TEXT NOT NULL
 );
-CREATE UNIQUE INDEX IF NOT EXISTS idx_subs_ws_instance
-  ON subscriptions(workspace_id, instance_id);
-CREATE INDEX IF NOT EXISTS idx_subs_instance_id ON subscriptions(instance_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_assignments_ws_instance
+  ON assignments(workspace_id, instance_id);
+CREATE INDEX IF NOT EXISTS idx_assignments_instance_id ON assignments(instance_id);
 `;
 async function legacySourcesPresent(client) {
   const rs = await client.execute(
@@ -508,6 +506,26 @@ async function runLibrariesMigration(client) {
   stmts.push({ sql: `DROP TABLE sources;` });
   await client.batch(stmts);
 }
+async function legacySubscriptionsPresent(client) {
+  const rs = await client.execute(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='subscriptions'"
+  );
+  return rs.rows.length > 0;
+}
+async function assignmentsPresent(client) {
+  const rs = await client.execute(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='assignments'"
+  );
+  return rs.rows.length > 0;
+}
+async function runAssignmentsMigration(client) {
+  await client.batch([
+    { sql: "ALTER TABLE subscriptions RENAME TO assignments;" },
+    { sql: "ALTER TABLE assignments RENAME COLUMN subscribed_at TO assigned_at;" },
+    { sql: "DROP INDEX IF EXISTS idx_subs_ws_instance;" },
+    { sql: "DROP INDEX IF EXISTS idx_subs_instance_id;" }
+  ]);
+}
 function assertNoLegacyLibDb(newDbPath) {
   if (fs11.existsSync(newDbPath)) return;
   const parent = path4.dirname(newDbPath);
@@ -547,6 +565,9 @@ async function createLibraryDb(dbPath) {
   if (await legacySourcesPresent(client) && !await librariesPresent(client)) {
     await runLibrariesMigration(client);
   }
+  if (await legacySubscriptionsPresent(client) && !await assignmentsPresent(client)) {
+    await runAssignmentsMigration(client);
+  }
   await client.executeMultiple(DDL);
   if (await librariesPresent(client)) {
     const storeRows = await client.execute({
@@ -571,85 +592,6 @@ async function createLibraryDb(dbPath) {
   const db = drizzle(client, { schema: schema_exports });
   return { db, close: () => client.close() };
 }
-function assertSafeManifestPath(installPath, p) {
-  const bad = () => {
-    throw new Error(`unsafe path in manifest: ${p}`);
-  };
-  if (!p || p.length === 0) bad();
-  if (isAbsolute(p) || p.startsWith("/") || p.startsWith("\\")) bad();
-  const segments = p.split(/[/\\]/);
-  if (segments.some((s) => s === "..")) bad();
-  const resolved = resolve(installPath, p);
-  if (resolved !== installPath && !resolved.startsWith(installPath + sep)) bad();
-}
-function assertSafeRefComponent(kind, value) {
-  const hasControlChar = [...value].some((c) => c.charCodeAt(0) < 32);
-  if (!value || value.startsWith(".") || /[/\\]/.test(value) || hasControlChar) {
-    throw new Error(`unsafe ref ${kind} component in manifest: '${value}'`);
-  }
-}
-async function installFromManifest(opts) {
-  const { manifest, libraryRoot } = opts;
-  const fetcher = opts.fetcher ?? (await import('./source-fetch-github-QN4LLTL5.js')).fetchAssetFilesFromGitHub;
-  let parsed;
-  try {
-    parsed = parseAssetRef(manifest.ref);
-  } catch (e) {
-    throw new Error(`invalid ref: ${manifest.ref}: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const publisher = parsed.publisher;
-  const name = parsed.name;
-  const version = parsed.pin;
-  if (!publisher) throw new Error(`invalid ref: ${manifest.ref} (missing publisher)`);
-  if (!version) throw new Error(`invalid ref: ${manifest.ref} (missing version pin)`);
-  assertSafeRefComponent("publisher", publisher);
-  assertSafeRefComponent("name", name);
-  assertSafeRefComponent("version", version);
-  const root = resolve(libraryRoot);
-  const installPath = resolve(join(root, `@${publisher}`, name, version));
-  if (installPath !== root && !installPath.startsWith(root + sep)) {
-    throw new Error(
-      `unsafe install path: ref '${manifest.ref}' resolves outside the library root`
-    );
-  }
-  for (const f of manifest.files) {
-    assertSafeManifestPath(installPath, f.path);
-  }
-  const paths = manifest.files.map((f) => f.path);
-  const bytes = await fetcher({
-    url: manifest.source.url,
-    commitSha: manifest.source.commitSha,
-    paths
-  });
-  for (const f of manifest.files) {
-    assertSafeManifestPath(installPath, f.path);
-    const buf = bytes[f.path];
-    if (!buf) throw new Error(`fetcher returned no bytes for ${f.path}`);
-    const actual = createHash("sha256").update(buf).digest("hex");
-    if (actual !== f.sha256) {
-      throw new Error(`hash mismatch for ${f.path}: expected ${f.sha256}, got ${actual}`);
-    }
-  }
-  const sortedLines = manifest.files.slice().sort((a, b) => a.path.localeCompare(b.path)).map((e) => `${e.path}:${e.sha256}
-`).join("");
-  const actualComposite = createHash("sha256").update(sortedLines, "utf-8").digest("hex");
-  if (actualComposite !== manifest.sha256) {
-    throw new Error(`composite hash mismatch: expected ${manifest.sha256}, got ${actualComposite}`);
-  }
-  await rm(installPath, { recursive: true, force: true });
-  try {
-    for (const f of manifest.files) {
-      const target = join(installPath, f.path);
-      await mkdir(dirname(target), { recursive: true });
-      await writeFile(target, bytes[f.path]);
-    }
-  } catch (e) {
-    await rm(installPath, { recursive: true, force: true }).catch(() => {
-    });
-    throw e;
-  }
-  return { installPath };
-}
 
 // library/src/local/library.ts
 function escapeLikePrefix(prefix) {
@@ -713,13 +655,13 @@ function rowToInstance(row) {
     sourceCommitSha: row.sourceCommitSha ?? void 0
   };
 }
-function rowToSubscription(row) {
+function rowToAssignment(row) {
   return {
     id: row.id,
     workspaceId: row.workspaceId,
     instanceId: row.instanceId,
     pinPolicy: row.pinPolicy,
-    subscribedAt: new Date(row.subscribedAt)
+    assignedAt: new Date(row.assignedAt)
   };
 }
 var LocalIndex = class {
@@ -1041,42 +983,42 @@ var LocalIndex = class {
     const db = await this.ensureDb();
     const existing = await db.select().from(instances).where(eq(instances.id, id)).get();
     if (!existing) throw new InstanceNotFoundError(id);
-    const consumers = await db.select().from(subscriptions).where(eq(subscriptions.instanceId, id)).all();
+    const consumers = await db.select().from(assignments).where(eq(assignments.instanceId, id)).all();
     if (consumers.length > 0 && !opts?.cascade) {
       throw new InstanceHasConsumersError(id, consumers.length);
     }
     await db.delete(instances).where(eq(instances.id, id)).run();
   }
-  // -- Subscriptions -------------------------------------------------------
-  async subscribe(workspaceId, instanceId, pin) {
+  // -- Assignments ---------------------------------------------------------
+  async assign(workspaceId, instanceId, pin) {
     const db = await this.ensureDb();
     const instance = await db.select().from(instances).where(eq(instances.id, instanceId)).get();
     if (!instance) throw new InstanceNotFoundError(instanceId);
-    const existing = await db.select().from(subscriptions).where(
+    const existing = await db.select().from(assignments).where(
       and(
-        eq(subscriptions.workspaceId, workspaceId),
-        eq(subscriptions.instanceId, instanceId)
+        eq(assignments.workspaceId, workspaceId),
+        eq(assignments.instanceId, instanceId)
       )
     ).get();
-    if (existing) throw new DuplicateSubscriptionError(workspaceId, instanceId);
+    if (existing) throw new DuplicateAssignmentError(workspaceId, instanceId);
     const id = crypto.randomUUID();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    await db.insert(subscriptions).values({ id, workspaceId, instanceId, pinPolicy: pin, subscribedAt: now }).run();
-    return { id, workspaceId, instanceId, pinPolicy: pin, subscribedAt: new Date(now) };
+    await db.insert(assignments).values({ id, workspaceId, instanceId, pinPolicy: pin, assignedAt: now }).run();
+    return { id, workspaceId, instanceId, pinPolicy: pin, assignedAt: new Date(now) };
   }
-  async unsubscribe(subscriptionId) {
+  async unassign(assignmentId) {
     const db = await this.ensureDb();
-    const existing = await db.select().from(subscriptions).where(eq(subscriptions.id, subscriptionId)).get();
-    if (!existing) throw new SubscriptionNotFoundError(subscriptionId);
-    await db.delete(subscriptions).where(eq(subscriptions.id, subscriptionId)).run();
+    const existing = await db.select().from(assignments).where(eq(assignments.id, assignmentId)).get();
+    if (!existing) throw new AssignmentNotFoundError(assignmentId);
+    await db.delete(assignments).where(eq(assignments.id, assignmentId)).run();
   }
-  async listSubscriptions(workspaceId) {
+  async listAssignments(workspaceId) {
     const db = await this.ensureDb();
-    return (await db.select().from(subscriptions).where(eq(subscriptions.workspaceId, workspaceId)).all()).map(rowToSubscription);
+    return (await db.select().from(assignments).where(eq(assignments.workspaceId, workspaceId)).all()).map(rowToAssignment);
   }
   async getConsumptionGraph(instanceId) {
     const db = await this.ensureDb();
-    return (await db.select().from(subscriptions).where(eq(subscriptions.instanceId, instanceId)).all()).map(rowToSubscription);
+    return (await db.select().from(assignments).where(eq(assignments.instanceId, instanceId)).all()).map(rowToAssignment);
   }
 };
 
@@ -1588,8 +1530,8 @@ var WorkspaceConfigV2Schema = z2.object({
   library: LibrarySectionSchema.optional(),
   presets_applied: z2.array(PresetAppliedSchema).optional()
 });
-var LockSubscriptionSchema = z2.object({
-  subscription_id: z2.string().uuid(),
+var LockAssignmentSchema = z2.object({
+  assignment_id: z2.string().uuid(),
   instance_id: z2.string().uuid(),
   def_ref: z2.string(),
   resolved_version: z2.string(),
@@ -1608,7 +1550,7 @@ var PresetExpandedSchema = z2.object({
 var LockFileSchema = z2.object({
   version: z2.literal(2),
   generated_at: z2.string(),
-  subscriptions: z2.array(LockSubscriptionSchema).default([]),
+  assignments: z2.array(LockAssignmentSchema).default([]),
   requires_graph: z2.array(RequiresEdgeSchema).default([]),
   presets_expanded: z2.array(PresetExpandedSchema).default([])
 });
@@ -1645,6 +1587,17 @@ function loadLockFile(dir) {
   if (!fs11.existsSync(filePath)) return null;
   const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
+  if (raw !== null && !("assignments" in raw) && "subscriptions" in raw) {
+    const legacySubs = raw["subscriptions"];
+    raw["assignments"] = Array.isArray(legacySubs) ? legacySubs.map((s) => {
+      if (s !== null && typeof s === "object" && "subscription_id" in s && !("assignment_id" in s)) {
+        const { subscription_id, ...rest } = s;
+        return { assignment_id: subscription_id, ...rest };
+      }
+      return s;
+    }) : [];
+    delete raw["subscriptions"];
+  }
   return LockFileSchema.parse(raw);
 }
 function saveLockFile(dir, lock) {
@@ -1663,7 +1616,7 @@ function createEmptyLockFile() {
   return {
     version: 2,
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    subscriptions: [],
+    assignments: [],
     requires_graph: [],
     presets_expanded: []
   };
@@ -3333,9 +3286,9 @@ async function applyPreset(presetRef, manifest, inputs, opts) {
   const pinPolicy = opts.pinPolicy ?? "minor-track";
   const depthError = validateNestingDepth(presetRef, depth);
   if (depthError) {
-    return { instances: [], subscriptions: [], errors: [depthError] };
+    return { instances: [], assignments: [], errors: [depthError] };
   }
-  const result = { instances: [], subscriptions: [], errors: [] };
+  const result = { instances: [], assignments: [], errors: [] };
   const itemResults = /* @__PURE__ */ new Map();
   for (const item of manifest.items) {
     const itemResult = await applyItemImpl(
@@ -3352,7 +3305,7 @@ async function applyPreset(presetRef, manifest, inputs, opts) {
     if (item.id && itemResult.instances.length > 0) {
       itemResults.set(item.id, itemResult.instances[0]);
     }
-    result.subscriptions.push(...itemResult.subscriptions);
+    result.assignments.push(...itemResult.assignments);
   }
   return result;
 }
@@ -3361,7 +3314,7 @@ async function applyPresetFromData(presetRef, data, inputs, opts) {
   if (!parseResult.ok || !parseResult.preset) {
     return {
       instances: [],
-      subscriptions: [],
+      assignments: [],
       errors: parseResult.errors.map((e) => `Parse: ${e}`)
     };
   }
@@ -3376,34 +3329,34 @@ async function applyItemImpl(presetRef, item, inputs, opts, depth, pinPolicy, it
       if (!target) {
         return {
           instances: [],
-          subscriptions: [],
+          assignments: [],
           errors: [
             `Cross-item ref "#${resolved.targetId}" not yet resolved (items must be ordered)`
           ]
         };
       }
-      return { instances: [target], subscriptions: [], errors: [] };
+      return { instances: [target], assignments: [], errors: [] };
     }
     case "library-instance": {
       if (!resolved.instance) {
         return {
           instances: [],
-          subscriptions: [],
+          assignments: [],
           errors: [`Library instance "${resolved.instanceId}" not found`]
         };
       }
       try {
-        const sub = await library.subscribe(opts.workspaceId, resolved.instanceId, pinPolicy);
-        return { instances: [resolved.instance], subscriptions: [sub], errors: [] };
+        const asgn = await library.assign(opts.workspaceId, resolved.instanceId, pinPolicy);
+        return { instances: [resolved.instance], assignments: [asgn], errors: [] };
       } catch {
-        return { instances: [resolved.instance], subscriptions: [], errors: [] };
+        return { instances: [resolved.instance], assignments: [], errors: [] };
       }
     }
     case "nested-preset": {
       if (!opts.loadPreset) {
         return {
           instances: [],
-          subscriptions: [],
+          assignments: [],
           errors: [`Cannot resolve nested preset "${resolved.presetRef}" \u2014 no loader provided`]
         };
       }
@@ -3411,13 +3364,13 @@ async function applyItemImpl(presetRef, item, inputs, opts, depth, pinPolicy, it
       if (!nestedData) {
         return {
           instances: [],
-          subscriptions: [],
+          assignments: [],
           errors: [`Nested preset "${resolved.presetRef}" not found`]
         };
       }
       const parseResult = parsePreset(nestedData);
       if (!parseResult.ok || !parseResult.preset) {
-        return { instances: [], subscriptions: [], errors: parseResult.errors };
+        return { instances: [], assignments: [], errors: parseResult.errors };
       }
       const nestedInputs = {
         ...item.inputs ?? {},
@@ -3429,7 +3382,7 @@ async function applyItemImpl(presetRef, item, inputs, opts, depth, pinPolicy, it
       });
       return {
         instances: nestedResult.instances,
-        subscriptions: nestedResult.subscriptions,
+        assignments: nestedResult.assignments,
         errors: nestedResult.errors
       };
     }
@@ -3442,12 +3395,12 @@ async function applyItemImpl(presetRef, item, inputs, opts, depth, pinPolicy, it
         const secretPhs = item.placeholders.filter((ph) => isSecretPlaceholder(ph));
         const validation = validateAllPlaceholders(nonSecretPhs, itemInputs);
         if (!validation.valid) {
-          return { instances: [], subscriptions: [], errors: validation.errors };
+          return { instances: [], assignments: [], errors: validation.errors };
         }
         validatedValues = validation.values;
         const secretValidation = validateAllPlaceholders(secretPhs, itemInputs);
         if (!secretValidation.valid) {
-          return { instances: [], subscriptions: [], errors: secretValidation.errors };
+          return { instances: [], assignments: [], errors: secretValidation.errors };
         }
         for (const [key, value] of Object.entries(secretValidation.values)) {
           secretValues[key] = String(value);
@@ -3470,7 +3423,7 @@ async function applyItemImpl(presetRef, item, inputs, opts, depth, pinPolicy, it
         } catch (err) {
           return {
             instances: [],
-            subscriptions: [],
+            assignments: [],
             errors: [
               `Secret storage failed for "${item.ref}": ${err instanceof Error ? err.message : String(err)}`
             ]
@@ -3485,17 +3438,17 @@ async function applyItemImpl(presetRef, item, inputs, opts, depth, pinPolicy, it
           credentialRef: interpolated.credentialRef,
           createdBy: opts.createdBy ?? `preset:${presetRef}`
         });
-        const subscriptions2 = [];
+        const assignments2 = [];
         try {
-          const sub = await library.subscribe(opts.workspaceId, instance.id, pinPolicy);
-          subscriptions2.push(sub);
+          const asgn = await library.assign(opts.workspaceId, instance.id, pinPolicy);
+          assignments2.push(asgn);
         } catch {
         }
-        return { instances: [instance], subscriptions: subscriptions2, errors: [] };
+        return { instances: [instance], assignments: assignments2, errors: [] };
       } catch (err) {
         return {
           instances: [],
-          subscriptions: [],
+          assignments: [],
           errors: [
             `Instance creation failed for "${item.ref}": ${err instanceof Error ? err.message : String(err)}`
           ]
@@ -3614,6 +3567,6 @@ function deepEqual(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
 }
 
-export { CatalogCache, CatalogConfigSchema, CatalogHttpError, DuplicateLibraryNameError, DuplicateSubscriptionError, GitSyncDriver, InstanceHasConsumersError, InstanceNotFoundError, InterpolationError, KNOWN_ASSET_KINDS, KnowledgeManifestSchema, LIBRARY_BACKENDS, LIBRARY_OWNERSHIPS, LIBRARY_STRUCTURES, LOCAL_CATALOG_URL, LibraryConfigSchema, LibraryError, LibraryInstanceRefSchema, LibraryManager, LibrarySectionSchema, LibrarySyncError, LocalCatalogSource, LocalIndex, LocalSyncDriver, LockFileSchema, LockSubscriptionSchema, OfflineError, OperationNotPermittedError, PIN_POLICIES, PinPolicySchema, PresetAppliedSchema, PresetExpandedSchema, RemoteCatalogSource, RequiresEdgeSchema, RestCatalogSource, SidecarGit, SkaileConfigSchema, SourceNotFoundError, SubscriptionNotFoundError, TarballHashMismatchError, UserLibraryNotFoundError, WorkspaceConfigV2Schema, applyNonStructuralUpgrade, applyPreset, applyPresetFromData, classifyRef, createEmptyLockFile, deriveSlug, detectChanges, detectNestedPresetRefs, detectWorkspaceVersion, evaluateUpgrade, extractLibraryInstanceId, extractReferencedKeys, filterKey, getConfigDefaults, getDefaultValue, getSidecarRoot, getStoreManifestsDir, getStoreRoot, hasInterpolationTokens, installFromManifest, interpolate, isLocalCatalogUrl, isSecretPlaceholder, knowledgeKindProvider, listSidecarSlugsOnDisk, loadLockFile, loadWorkspaceV2, migrateSidecarsToStoreIfNeeded, migrateWorkspaceConfig, parsePreset, parsePresetYaml, parseWorkspaceV2, projectConfigPath, queryInstancePickerChoices, resolveAllItems, resolveConfig, resolveIndexPath, resolveItem, resolveLibraryDir, resolvePin, resolveSidecarPaths, saveConfig, saveLockFile, saveWorkspaceV2, sha256Hex, skaileHomeDir, storeSecrets, trpcGetUrl, userConfigPath, validateAllPlaceholders, validateKnowledge, validateNestingDepth, validatePlaceholder, writeManifestIfMissing };
-//# sourceMappingURL=chunk-RTAIGPTF.js.map
-//# sourceMappingURL=chunk-RTAIGPTF.js.map
+export { AssignmentNotFoundError, CatalogCache, CatalogConfigSchema, CatalogHttpError, DuplicateAssignmentError, DuplicateLibraryNameError, GitSyncDriver, InstanceHasConsumersError, InstanceNotFoundError, InterpolationError, KNOWN_ASSET_KINDS, KnowledgeManifestSchema, LIBRARY_BACKENDS, LIBRARY_OWNERSHIPS, LIBRARY_STRUCTURES, LOCAL_CATALOG_URL, LibraryConfigSchema, LibraryError, LibraryInstanceRefSchema, LibraryManager, LibrarySectionSchema, LibrarySyncError, LocalCatalogSource, LocalIndex, LocalSyncDriver, LockAssignmentSchema, LockFileSchema, OfflineError, OperationNotPermittedError, PIN_POLICIES, PinPolicySchema, PresetAppliedSchema, PresetExpandedSchema, RemoteCatalogSource, RequiresEdgeSchema, RestCatalogSource, SidecarGit, SkaileConfigSchema, SourceNotFoundError, TarballHashMismatchError, UserLibraryNotFoundError, WorkspaceConfigV2Schema, applyNonStructuralUpgrade, applyPreset, applyPresetFromData, classifyRef, createEmptyLockFile, deriveSlug, detectChanges, detectNestedPresetRefs, detectWorkspaceVersion, evaluateUpgrade, extractLibraryInstanceId, extractReferencedKeys, filterKey, getConfigDefaults, getDefaultValue, getSidecarRoot, getStoreManifestsDir, getStoreRoot, hasInterpolationTokens, interpolate, isLocalCatalogUrl, isSecretPlaceholder, knowledgeKindProvider, listSidecarSlugsOnDisk, loadLockFile, loadWorkspaceV2, migrateSidecarsToStoreIfNeeded, migrateWorkspaceConfig, parsePreset, parsePresetYaml, parseWorkspaceV2, projectConfigPath, queryInstancePickerChoices, resolveAllItems, resolveConfig, resolveIndexPath, resolveItem, resolveLibraryDir, resolvePin, resolveSidecarPaths, saveConfig, saveLockFile, saveWorkspaceV2, sha256Hex, skaileHomeDir, storeSecrets, trpcGetUrl, userConfigPath, validateAllPlaceholders, validateKnowledge, validateNestingDepth, validatePlaceholder, writeManifestIfMissing };
+//# sourceMappingURL=chunk-MIH45XPY.js.map
+//# sourceMappingURL=chunk-MIH45XPY.js.map