@skaile/workspaces 0.27.0 → 0.28.1

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

@@ -50,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";
@@ -99,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({
@@ -198,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. */
@@ -256,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() {
@@ -417,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(
@@ -506,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);
@@ -545,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({
@@ -632,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 {
@@ -960,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);
   }
 };
 
@@ -1507,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(),
@@ -1527,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([])
 });
@@ -1564,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) {
@@ -1582,7 +1616,7 @@ function createEmptyLockFile() {
   return {
     version: 2,
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    subscriptions: [],
+    assignments: [],
     requires_graph: [],
     presets_expanded: []
   };
@@ -3252,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(
@@ -3271,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;
 }
@@ -3280,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}`)
     };
   }
@@ -3295,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`]
         };
       }
@@ -3330,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 ?? {},
@@ -3348,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
       };
     }
@@ -3361,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);
@@ -3389,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)}`
             ]
@@ -3404,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)}`
           ]
@@ -3533,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, 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-WRRYESHC.js.map
-//# sourceMappingURL=chunk-WRRYESHC.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