@weasel-js/labkit 1.4.4 → 1.5.0

package/dist/chunk-67SJLMC7.js

@@ -0,0 +1,704 @@
+import { newId, emptyUndoStack, deserializeTrials, openRecords, labPrefix, documentOfRecords, recordsOfDocument, trialRecord, trialValuesPrefix, saveRecord, LAYOUT_RECORD, UNDOCK_RECORD, META_RECORD, parseRecordName, compareTrialOrder, serializeTrials, labStorageKey } from './chunk-RWNDDKOH.js';
+import { withValueAtPath, fillConfigDefaults } from './chunk-E44SU6XS.js';
+import { LabStoreContext, TrialIdContext } from './chunk-2YILQ7Y5.js';
+import { createStore } from 'zustand/vanilla';
+import { useContext } from 'react';
+import { useStore } from 'zustand/react';
+
+// src/state/document.ts
+var CURRENT_DOCUMENT_VERSION = 4;
+function labDocumentKey(storageKey) {
+  return `lk:${storageKey}:doc`;
+}
+function quarantineKey(storageKey) {
+  return `lk:${storageKey}:quarantine`;
+}
+function emptyDocument(mode) {
+  return {
+    version: CURRENT_DOCUMENT_VERSION,
+    undockedPanels: {},
+    trials: [],
+    saves: [],
+    layout: {},
+    mode
+  };
+}
+function runMigrations(raw, migrations, target) {
+  const from = typeof raw.version === "number" ? raw.version : 0;
+  if (from > target) return { ok: false, reason: "future" };
+  if (from === target) return { ok: true, doc: raw, migrated: false };
+  let doc = raw;
+  try {
+    for (let v = from; v < target; v++) {
+      const migration = migrations[v];
+      if (!migration) throw new Error(`[labkit] no migration from version ${v}`);
+      doc = migration(doc);
+    }
+  } catch (error) {
+    return { ok: false, reason: "failed", error };
+  }
+  return { ok: true, doc, migrated: true };
+}
+var LEGACY_BUCKETS = ["workspaces", "saves", "layout", "theme"];
+function legacyKeys(storageKey) {
+  return LEGACY_BUCKETS.map((bucket) => labStorageKey(storageKey, bucket));
+}
+function parseStored(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function bucketOr(value, fallback, bucket, shape) {
+  if (value === void 0) return fallback;
+  const parsed = parseStored(value);
+  const fits = shape === "array" ? Array.isArray(parsed) : !!parsed && typeof parsed === "object";
+  if (fits) return parsed;
+  console.warn(`[labkit] unparseable legacy bucket "${bucket}", dropping it`);
+  return fallback;
+}
+async function readLegacyDocument(read, storageKey, fallbackMode) {
+  const [workspaces, saves, layout, theme] = await Promise.all(
+    LEGACY_BUCKETS.map((bucket) => read(labStorageKey(storageKey, bucket)))
+  );
+  if ([workspaces, saves, layout, theme].every((v) => v === void 0)) return null;
+  const mode = theme === "light" || theme === "dark" || theme === "auto" || theme === "interstellar" ? theme : fallbackMode;
+  return {
+    version: 0,
+    workspaces: bucketOr(workspaces, [], "workspaces", "array"),
+    saves: bucketOr(saves, [], "saves", "array"),
+    layout: bucketOr(layout, {}, "layout", "object"),
+    mode
+  };
+}
+function sameStored(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+async function deleteConfirmed(storage, keys) {
+  try {
+    await Promise.all(keys.map((key) => storage.delete(key)));
+    const left = await Promise.all(keys.map((key) => storage.get(key)));
+    return left.every((v) => v === void 0);
+  } catch {
+    return false;
+  }
+}
+async function quarantineDocument(storage, storageKey, value) {
+  try {
+    await storage.set(quarantineKey(storageKey), value);
+    return sameStored(await storage.get(quarantineKey(storageKey)), value);
+  } catch {
+    return false;
+  }
+}
+function normalizeDocument(doc, fallbackMode) {
+  const mode = doc.mode === "light" || doc.mode === "dark" || doc.mode === "auto" ? doc.mode : fallbackMode;
+  return {
+    version: CURRENT_DOCUMENT_VERSION,
+    trials: Array.isArray(doc.trials) ? doc.trials : [],
+    saves: Array.isArray(doc.saves) ? doc.saves : [],
+    layout: doc.layout && typeof doc.layout === "object" ? doc.layout : {},
+    undockedPanels: doc.undockedPanels && typeof doc.undockedPanels === "object" ? doc.undockedPanels : {},
+    mode
+  };
+}
+function migrateV0toV1(doc) {
+  const raw = doc.mode === "interstellar" ? "dark" : doc.mode;
+  const mode = raw === "light" || raw === "dark" || raw === "auto" ? raw : "auto";
+  return {
+    version: 1,
+    workspaces: Array.isArray(doc.workspaces) ? doc.workspaces : [],
+    saves: Array.isArray(doc.saves) ? doc.saves : [],
+    layout: doc.layout && typeof doc.layout === "object" ? doc.layout : {},
+    mode
+  };
+}
+function migrateV1toV2(doc) {
+  const { workspaces, ...rest } = doc;
+  return { ...rest, trials: Array.isArray(workspaces) ? workspaces : [], version: 2 };
+}
+function migrateV2toV3(doc) {
+  return { ...doc, undockedPanels: {}, version: 3 };
+}
+function migrateV3toV4(doc) {
+  return { ...doc, version: 4 };
+}
+var MIGRATIONS = [migrateV0toV1, migrateV1toV2, migrateV2toV3, migrateV3toV4];
+
+// src/state/undock.ts
+function panelKey(trialId, sectionId) {
+  return `${trialId}::${sectionId}`;
+}
+function undockPanel(panels, trialId, sectionId, as = "tile") {
+  return { ...panels, [panelKey(trialId, sectionId)]: { trialId, sectionId, as } };
+}
+function dockPanel(panels, trialId, sectionId) {
+  const out = {};
+  for (const [key, panel] of Object.entries(panels)) {
+    if (panel.trialId === trialId && (sectionId === void 0 || panel.sectionId === sectionId)) {
+      continue;
+    }
+    out[key] = panel;
+  }
+  return out;
+}
+
+// src/instrument/serializers.ts
+function configDefaultsOf(instruments) {
+  const out = {};
+  for (const instrument of instruments) out[instrument.name] = () => instrument.defaultConfig();
+  return out;
+}
+function configMigrationsOf(instruments) {
+  const out = {};
+  for (const { name, migrateConfig } of instruments) {
+    if (migrateConfig) out[name] = (stored) => migrateConfig(stored);
+  }
+  return out;
+}
+function serializersOf(instruments) {
+  const out = {};
+  for (const instrument of instruments) {
+    const { name, serialize, deserialize } = instrument;
+    if (!serialize && !deserialize) continue;
+    out[name] = {
+      ...serialize ? { serialize: (state) => serialize(state) } : {},
+      ...deserialize ? { deserialize: (data, config) => deserialize(data, config) } : {}
+    };
+  }
+  return out;
+}
+
+// src/state/store.ts
+function createLabStore(options = {}) {
+  let hooks = options.instruments ? hooksOf(options.instruments) : {
+    serializers: options.serializers ?? {},
+    configDefaults: options.configDefaults ?? {},
+    configMigrations: options.configMigrations ?? {}
+  };
+  const initial = options.initial ?? emptyDocument(options.initialMode ?? "auto");
+  const store = createStore()((set, get) => ({
+    trials: hydrateTrials(initial.trials, hooks.serializers, hooks),
+    savedSnapshots: hydrateSnapshots(initial.saves, hooks),
+    mode: initial.mode,
+    layout: initial.layout,
+    undockedPanels: initial.undockedPanels,
+    activeToolId: null,
+    instruments: options.instruments ?? null,
+    addTrial: (record) => {
+      set((s) => ({
+        trials: [...s.trials, { ...record, undoStack: emptyUndoStack() }]
+      }));
+    },
+    removeTrial: (id) => {
+      set((s) => ({
+        trials: s.trials.filter((w) => w.id !== id),
+        undockedPanels: dockPanel(s.undockedPanels, id)
+      }));
+    },
+    updateTrialState: (id, next) => {
+      set((s) => ({
+        trials: s.trials.map((w) => {
+          if (w.id !== id) return w;
+          const nextState = typeof next === "function" ? next(w.state) : next;
+          if (Object.is(nextState, w.state)) return w;
+          return { ...w, state: nextState };
+        })
+      }));
+    },
+    updateTrialConfig: (id, path, value) => {
+      set((s) => ({
+        trials: s.trials.map(
+          (w) => w.id === id ? { ...w, config: withValueAtPath(w.config, path, value) } : w
+        )
+      }));
+    },
+    updateTrialView: (id, view) => {
+      set((s) => ({
+        trials: s.trials.map((w) => w.id === id && !Object.is(view, w.view) ? { ...w, view } : w)
+      }));
+    },
+    updateTrialSidebarWidth: (id, width) => {
+      set((s) => ({
+        trials: s.trials.map(
+          (w) => w.id === id && w.sidebarWidth !== width ? { ...w, sidebarWidth: width } : w
+        )
+      }));
+    },
+    setTrialTitle: (id, title) => {
+      set((s) => ({
+        trials: s.trials.map((w) => {
+          if (w.id !== id) return w;
+          const next = title === null ? void 0 : title;
+          if ((w.title ?? void 0) === next) return w;
+          return { ...w, title: next };
+        })
+      }));
+    },
+    setTrialSectionCollapsed: (id, key, collapsed) => {
+      set((s) => ({
+        trials: s.trials.map((w) => {
+          if (w.id !== id) return w;
+          if (w.collapsedSections?.[key] === collapsed) return w;
+          return { ...w, collapsedSections: { ...w.collapsedSections, [key]: collapsed } };
+        })
+      }));
+    },
+    updateTrialAnnotations: (id, doc) => {
+      set((s) => ({
+        trials: s.trials.map(
+          (w) => w.id === id && !Object.is(doc, w.annotations) ? { ...w, annotations: doc } : w
+        )
+      }));
+    },
+    updateTrialUndoStack: (id, next) => {
+      set((s) => ({
+        trials: s.trials.map((w) => {
+          if (w.id !== id) return w;
+          const undoStack = typeof next === "function" ? next(w.undoStack) : next;
+          return { ...w, undoStack };
+        })
+      }));
+    },
+    setTrialInstrument: (id, instrumentName) => {
+      set((s) => ({
+        trials: s.trials.map((w) => w.id === id ? { ...w, instrumentName } : w)
+      }));
+    },
+    saveSnapshot: (trialId, name) => {
+      const trial = get().trials.find((w) => w.id === trialId);
+      if (!trial) return;
+      const reg = hooks.serializers[trial.instrumentName];
+      const serializedState = reg?.serialize ? reg.serialize(trial.state) : structuredClone(trial.state);
+      const clonedConfig = structuredClone(trial.config);
+      const lastAt = get().savedSnapshots.reduce((m, sn) => sn.savedAt > m ? sn.savedAt : m, 0);
+      const savedAt = Math.max(Date.now(), lastAt + 1);
+      const snapshot = {
+        id: newId(),
+        name,
+        trialId,
+        instrumentName: trial.instrumentName,
+        config: clonedConfig,
+        state: serializedState,
+        savedAt
+      };
+      set((s) => ({ savedSnapshots: [...s.savedSnapshots, snapshot] }));
+    },
+    loadSnapshot: (snapshotId, trialId) => {
+      const snapshot = get().savedSnapshots.find((sn) => sn.id === snapshotId);
+      if (!snapshot) return;
+      const trial = get().trials.find((w) => w.id === trialId);
+      if (!trial) return;
+      if (snapshot.instrumentName !== trial.instrumentName) {
+        console.warn(
+          `[labkit] loadSnapshot: instrument mismatch (snapshot=${snapshot.instrumentName}, trial=${trial.instrumentName}); refusing to load`
+        );
+        return;
+      }
+      const reg = hooks.serializers[snapshot.instrumentName];
+      const restoredState = reg?.deserialize ? reg.deserialize(snapshot.state, snapshot.config) : snapshot.state;
+      set((s) => ({
+        trials: s.trials.map(
+          (w) => w.id === trialId ? { ...w, state: restoredState, config: snapshot.config } : w
+        )
+      }));
+    },
+    deleteSnapshot: (snapshotId) => {
+      set((s) => ({
+        savedSnapshots: s.savedSnapshots.filter((sn) => sn.id !== snapshotId)
+      }));
+    },
+    listSnapshots: (trialId) => {
+      const all = get().savedSnapshots;
+      const filtered = trialId ? all.filter((sn) => sn.trialId === trialId) : all;
+      return [...filtered].sort((a, b) => b.savedAt - a.savedAt);
+    },
+    setMode: (mode) => {
+      set({ mode });
+    },
+    setLabTool: (id) => set({ activeToolId: id }),
+    setTrialTool: (trialId, id) => set((s) => ({
+      trials: s.trials.map((t) => t.id === trialId ? { ...t, activeToolId: id } : t)
+    })),
+    undockPanel: (trialId, sectionId, as) => {
+      set((s) => ({ undockedPanels: undockPanel(s.undockedPanels, trialId, sectionId, as) }));
+    },
+    dockPanel: (trialId, sectionId) => {
+      set((s) => ({ undockedPanels: dockPanel(s.undockedPanels, trialId, sectionId) }));
+    },
+    setLayout: (layout) => {
+      set({ layout });
+    },
+    setInstruments: (instruments) => {
+      const before = get().instruments;
+      if (before === instruments) return;
+      const next = mergedHooks(hooks, instruments);
+      const previous = new Map((before ?? []).map((i) => [i.name, i]));
+      const changed = new Set(
+        instruments.filter((i) => previous.get(i.name) !== i).map((i) => i.name)
+      );
+      if (changed.size === 0) {
+        hooks = next;
+        set({ instruments });
+        return;
+      }
+      const s = get();
+      const trials = s.trials.map(
+        (w) => changed.has(w.instrumentName) ? { ...w, config: hydratedConfig(next, w.instrumentName, w.config) } : w
+      );
+      const savedSnapshots = s.savedSnapshots.map(
+        (sn) => changed.has(sn.instrumentName) ? { ...sn, config: hydratedConfig(next, sn.instrumentName, sn.config) } : sn
+      );
+      hooks = next;
+      set({ instruments, trials, savedSnapshots });
+    },
+    instrumentHooks: () => hooks
+  }));
+  return store;
+}
+function hooksOf(instruments) {
+  return {
+    serializers: serializersOf(instruments),
+    configDefaults: configDefaultsOf(instruments),
+    configMigrations: configMigrationsOf(instruments)
+  };
+}
+function mergedHooks(old, instruments) {
+  const listed = new Set(instruments.map((i) => i.name));
+  const fresh = hooksOf(instruments);
+  const unlisted = (entries) => Object.fromEntries(Object.entries(entries).filter(([name]) => !listed.has(name)));
+  return {
+    serializers: { ...unlisted(old.serializers), ...fresh.serializers },
+    configDefaults: { ...unlisted(old.configDefaults), ...fresh.configDefaults },
+    configMigrations: { ...unlisted(old.configMigrations), ...fresh.configMigrations }
+  };
+}
+function hydratedConfig(hydration, instrumentName, config) {
+  const migrate = hydration.configMigrations?.[instrumentName];
+  const moved = migrate ? migrate(config) : config;
+  const defaults = hydration.configDefaults?.[instrumentName];
+  return defaults ? fillConfigDefaults(moved, defaults()) : moved;
+}
+function hydrateTrials(trials, serializers, hydration = {}) {
+  return deserializeTrials(
+    trials.map((t) => ({ ...t, config: hydratedConfig(hydration, t.instrumentName, t.config) })),
+    serializers
+  );
+}
+function hydrateSnapshots(saves, hydration = {}) {
+  return saves.map((sn) => ({
+    ...sn,
+    config: hydratedConfig(hydration, sn.instrumentName, sn.config)
+  }));
+}
+
+// src/state/openLabStore.ts
+async function openLabStore(options) {
+  const records = await openRecords({
+    storage: options.storage,
+    prefix: labPrefix(options.storageKey)
+  });
+  const { doc, orders } = await readLab(options, records);
+  const store = createLabStore({ ...options, initial: doc });
+  const unbind = bindLabStore(store, records, { orders });
+  return {
+    store,
+    records,
+    close: async () => {
+      unbind();
+      await records.close();
+    }
+  };
+}
+function emptyLab(mode) {
+  return { doc: emptyDocument(mode), orders: /* @__PURE__ */ new Map() };
+}
+function ordersOf(doc) {
+  return new Map(doc.trials.map((t, i) => [t.id, i]));
+}
+async function readLab(options, records) {
+  const mode = options.initialMode ?? "auto";
+  if (!records.writable) return emptyLab(mode);
+  const joined = documentOfRecords(records.entries());
+  if (!joined) return foldOldStorage(options, records);
+  const outcome = runMigrations(joined.doc, MIGRATIONS, CURRENT_DOCUMENT_VERSION);
+  if (outcome.ok) {
+    return { doc: normalizeDocument(outcome.doc, mode), orders: joined.orders };
+  }
+  const why = outcome.reason === "future" ? "are from a newer version of labkit" : "failed to migrate";
+  console.warn(`[labkit] lab records ${why}; starting empty and leaving them alone`, outcome.error);
+  records.stopWriting();
+  return emptyLab(mode);
+}
+async function foldOldStorage(options, records) {
+  const { storage, storageKey } = options;
+  const mode = options.initialMode ?? "auto";
+  let raw;
+  let oldKeys;
+  try {
+    const stored = await storage.get(labDocumentKey(storageKey));
+    if (stored !== void 0) {
+      raw = stored;
+      oldKeys = [labDocumentKey(storageKey)];
+    } else {
+      raw = await readLegacyDocument((key) => storage.get(key), storageKey, mode);
+      oldKeys = legacyKeys(storageKey);
+      if (raw === null) return emptyLab(mode);
+    }
+  } catch (error) {
+    console.warn(
+      `[labkit] could not read the old storage for "${storageKey}"; not persisting`,
+      error
+    );
+    records.stopWriting();
+    return emptyLab(mode);
+  }
+  const setAside = async (value, why, error) => {
+    if (await quarantineDocument(storage, storageKey, value)) {
+      console.warn(`[labkit] ${why}; quarantined it and starting empty`, error);
+      await deleteConfirmed(storage, oldKeys);
+      records.set(META_RECORD, { version: CURRENT_DOCUMENT_VERSION, mode });
+    } else {
+      console.warn(
+        `[labkit] ${why} and could not be quarantined; leaving it in place and not persisting`,
+        error
+      );
+      records.stopWriting();
+    }
+    return emptyLab(mode);
+  };
+  const parsed = parseStored(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return setAside(raw, "lab document is unparseable");
+  }
+  const outcome = runMigrations(
+    parsed,
+    MIGRATIONS,
+    CURRENT_DOCUMENT_VERSION
+  );
+  if (!outcome.ok) {
+    if (outcome.reason === "future") {
+      console.warn(
+        "[labkit] lab document is from a newer version of labkit; starting empty and leaving it alone"
+      );
+      records.stopWriting();
+      return emptyLab(mode);
+    }
+    return setAside(parsed, "lab document failed to migrate", outcome.error);
+  }
+  const doc = normalizeDocument(outcome.doc, mode);
+  const entries = recordsOfDocument(doc);
+  records.seed(entries);
+  if (await writeConfirmed(storage, records.prefix, entries)) {
+    await deleteConfirmed(storage, oldKeys);
+  } else {
+    console.warn(
+      `[labkit] keeping the old storage for "${storageKey}": could not confirm its records were written`
+    );
+  }
+  return { doc, orders: ordersOf(doc) };
+}
+async function writeConfirmed(storage, prefix, entries) {
+  try {
+    for (const [name, value] of entries) await storage.set(prefix + name, value);
+    const back = new Map(await storage.list(prefix));
+    return entries.every(([name, value]) => sameStored(back.get(prefix + name), value));
+  } catch {
+    return false;
+  }
+}
+function persistedFieldsDiffer(a, b) {
+  if (a === b) return false;
+  const left = a;
+  const right = b;
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])) {
+    if (key !== "undoStack" && !Object.is(left[key], right[key])) return true;
+  }
+  return false;
+}
+function bindLabStore(store, records, options) {
+  const orderOf = new Map(options.orders);
+  let applyingRemote = false;
+  const nextOrder = () => {
+    let max = -1;
+    for (const order of orderOf.values()) max = Math.max(max, order);
+    return max + 1;
+  };
+  const writeTrial = (trial) => {
+    const [serialized] = serializeTrials([trial], store.getState().instrumentHooks().serializers);
+    records.set(trialRecord(trial.id), { ...serialized, order: orderOf.get(trial.id) });
+  };
+  const inStoredOrder = (trials) => {
+    for (let i = 1; i < trials.length; i++) {
+      const a = trials[i - 1];
+      const b = trials[i];
+      const at = { trial: a, order: orderOf.get(a.id) ?? 0 };
+      const bt = { trial: b, order: orderOf.get(b.id) ?? 0 };
+      if (compareTrialOrder(at, bt) >= 0) return false;
+    }
+    return true;
+  };
+  const offStore = store.subscribe((state, prev) => {
+    if (applyingRemote) return;
+    let wrote = false;
+    if (state.trials !== prev.trials) {
+      const before = new Map(prev.trials.map((t) => [t.id, t]));
+      const now = new Set(state.trials.map((t) => t.id));
+      for (const t of prev.trials) {
+        if (now.has(t.id)) continue;
+        records.delete(trialRecord(t.id));
+        for (const [name] of records.entries(trialValuesPrefix(t.id))) records.delete(name);
+        orderOf.delete(t.id);
+        wrote = true;
+      }
+      const added = state.trials.filter((t) => !before.has(t.id));
+      for (const t of added) orderOf.set(t.id, nextOrder());
+      if (inStoredOrder(state.trials)) {
+        for (const t of state.trials) {
+          const old = before.get(t.id);
+          if (old && !persistedFieldsDiffer(old, t)) continue;
+          writeTrial(t);
+          wrote = true;
+        }
+      } else {
+        for (const [i, t] of state.trials.entries()) orderOf.set(t.id, i);
+        for (const t of state.trials) writeTrial(t);
+        wrote = true;
+      }
+    }
+    if (state.savedSnapshots !== prev.savedSnapshots) {
+      const before = new Map(prev.savedSnapshots.map((s) => [s.id, s]));
+      const now = new Set(state.savedSnapshots.map((s) => s.id));
+      for (const s of state.savedSnapshots) {
+        if (before.get(s.id) === s) continue;
+        records.set(saveRecord(s.id), s);
+        wrote = true;
+      }
+      for (const s of prev.savedSnapshots) {
+        if (now.has(s.id)) continue;
+        records.delete(saveRecord(s.id));
+        wrote = true;
+      }
+    }
+    if (state.layout !== prev.layout) {
+      records.set(LAYOUT_RECORD, state.layout);
+      wrote = true;
+    }
+    if (state.undockedPanels !== prev.undockedPanels) {
+      records.set(UNDOCK_RECORD, state.undockedPanels);
+      wrote = true;
+    }
+    if (state.mode !== prev.mode || wrote && !records.has(META_RECORD)) {
+      records.set(META_RECORD, {
+        version: CURRENT_DOCUMENT_VERSION,
+        mode: state.mode
+      });
+    }
+  });
+  const offRecords = records.subscribe((changes) => {
+    const remote = changes.filter((c) => c.origin === "remote");
+    if (remote.length === 0) return;
+    const current = store.getState();
+    let trials = current.trials;
+    let saves = current.savedSnapshots;
+    const patch = {};
+    for (const { name, value } of remote) {
+      const parsed = parseRecordName(name);
+      if (!parsed) continue;
+      switch (parsed.kind) {
+        case "trial": {
+          const id = parsed.id;
+          if (value === void 0 || !value || typeof value !== "object") {
+            trials = trials.filter((t) => t.id !== id);
+            orderOf.delete(id);
+            break;
+          }
+          const { order, ...rest } = value;
+          orderOf.set(
+            id,
+            typeof order === "number" && Number.isFinite(order) ? order : nextOrder()
+          );
+          const hooks = store.getState().instrumentHooks();
+          const [replacement] = hydrateTrials([{ ...rest, id }], hooks.serializers, hooks);
+          if (!replacement) break;
+          trials = trials.some((t) => t.id === id) ? trials.map((t) => t.id === id ? replacement : t) : [...trials, replacement];
+          break;
+        }
+        case "save": {
+          const id = parsed.id;
+          if (value === void 0 || !value || typeof value !== "object") {
+            saves = saves.filter((s) => s.id !== id);
+            break;
+          }
+          const [snapshot] = hydrateSnapshots(
+            [{ ...value, id }],
+            store.getState().instrumentHooks()
+          );
+          if (!snapshot) break;
+          saves = saves.some((s) => s.id === id) ? saves.map((s) => s.id === id ? snapshot : s) : [...saves, snapshot];
+          break;
+        }
+        case "layout":
+          patch.layout = value ?? {};
+          break;
+        case "undock":
+          patch.undockedPanels = value ?? {};
+          break;
+        case "meta": {
+          const meta = value;
+          if (typeof meta?.version === "number" && meta.version > CURRENT_DOCUMENT_VERSION) {
+            console.warn(
+              "[labkit] another tab wrote this lab with a newer labkit; no longer persisting"
+            );
+            if ("stopWriting" in records) records.stopWriting();
+            break;
+          }
+          if (meta?.mode === "light" || meta?.mode === "dark" || meta?.mode === "auto") {
+            patch.mode = meta.mode;
+          }
+          break;
+        }
+      }
+    }
+    if (trials !== current.trials) {
+      trials = [...trials].sort(
+        (a, b) => compareTrialOrder(
+          { trial: a, order: orderOf.get(a.id) ?? 0 },
+          { trial: b, order: orderOf.get(b.id) ?? 0 }
+        )
+      );
+    }
+    applyingRemote = true;
+    try {
+      store.setState({ ...patch, trials, savedSnapshots: saves });
+    } finally {
+      applyingRemote = false;
+    }
+  });
+  return () => {
+    offStore();
+    offRecords();
+  };
+}
+function useTrialState() {
+  const ctx = useContext(LabStoreContext);
+  if (!ctx) throw new Error("[labkit] useTrialState must be used inside <LabStoreProvider>");
+  const trialId = useContext(TrialIdContext);
+  if (!trialId) throw new Error("[labkit] useTrialState must be used inside <TrialIdProvider>");
+  const record = useStore(ctx.store, (s) => s.trials.find((w) => w.id === trialId));
+  if (!record) throw new Error(`[labkit] No trial found with id "${trialId}"`);
+  const updateTrialState = useStore(ctx.store, (s) => s.updateTrialState);
+  const updateTrialConfig = useStore(ctx.store, (s) => s.updateTrialConfig);
+  return {
+    state: record.state,
+    config: record.config,
+    setState: (next) => updateTrialState(trialId, next),
+    setConfig: (path, value) => updateTrialConfig(trialId, path, value)
+  };
+}
+
+export { CURRENT_DOCUMENT_VERSION, createLabStore, dockPanel, labDocumentKey, openLabStore, panelKey, quarantineKey, undockPanel, useTrialState };
+//# sourceMappingURL=chunk-67SJLMC7.js.map
+//# sourceMappingURL=chunk-67SJLMC7.js.map