@abraca/nuxt 2.0.11 → 2.4.0

package/dist/runtime/composables/usePluginCatalog.js

@@ -0,0 +1,234 @@
+import { ref, computed, shallowRef } from "vue";
+import { useRuntimeConfig } from "#imports";
+import { useInstalledPlugins } from "./useInstalledPlugins.js";
+export function usePluginCatalog() {
+  const cfg = useRuntimeConfig();
+  const base = cfg.public.abracadabra?.pluginRegistry?.url || "http://127.0.0.1:8787";
+  const plugins = shallowRef([]);
+  const isLoading = ref(false);
+  const error = ref(null);
+  const pagination = ref(null);
+  const details = shallowRef({});
+  const policy = ref(null);
+  async function list(params = {}) {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const url = new URL(`${base.replace(/\/$/, "")}/v1/plugins`);
+      if (params.category) url.searchParams.set("category", params.category);
+      if (params.search) url.searchParams.set("search", params.search);
+      if (typeof params.limit === "number") url.searchParams.set("limit", String(params.limit));
+      if (typeof params.offset === "number") url.searchParams.set("offset", String(params.offset));
+      const result = await $fetch(url.toString());
+      plugins.value = result.plugins;
+      pagination.value = result.pagination;
+      return result;
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error(String(e));
+      throw error.value;
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  async function get(id) {
+    if (details.value[id]) return details.value[id];
+    const detail = await $fetch(`${base.replace(/\/$/, "")}/v1/plugins/${encodeURIComponent(id)}`);
+    details.value = { ...details.value, [id]: detail };
+    return detail;
+  }
+  async function getLatest(id) {
+    return await $fetch(
+      `${base.replace(/\/$/, "")}/v1/plugins/${encodeURIComponent(id)}/latest`
+    );
+  }
+  async function getVersion(id, version) {
+    return await $fetch(
+      `${base.replace(/\/$/, "")}/v1/plugins/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}`
+    );
+  }
+  const installed = useInstalledPlugins();
+  function isInstalled(id) {
+    return installed.entries.value.some((e) => e.name === id || e.url.includes(`/${id}/`));
+  }
+  async function install(id) {
+    const decision = policyDecisionFor(id);
+    if (decision.state === "blocked") {
+      throw new Error(`install refused by server policy: ${decision.reason}`);
+    }
+    const latest = await getLatest(id);
+    if (!latest.artifact_url) {
+      throw new Error(
+        `plugin "${id}" version ${latest.version} has no artifact URL \u2014 registry artifact storage not configured yet`
+      );
+    }
+    installed.install(latest.artifact_url);
+    installed.updateMeta(latest.artifact_url, {
+      name: id,
+      version: latest.version,
+      label: latest.manifest.name ?? id,
+      description: latest.manifest.description
+    });
+    return latest;
+  }
+  async function installFromUrl(url) {
+    const p = policy.value;
+    if (p && !p.allow_unsafe_install) {
+      throw new Error(
+        "install refused by server policy: out-of-registry URL/file installs are disabled"
+      );
+    }
+    installed.install(url);
+  }
+  async function checkUpdates() {
+    const p = policy.value;
+    if (p && p.auto_update === "off") return [];
+    const outcomes = [];
+    for (const entry of installed.entries.value) {
+      if (!entry.name || !entry.version) continue;
+      let latest;
+      try {
+        latest = await getLatest(entry.name);
+      } catch {
+        continue;
+      }
+      const decision = policyDecisionFor(entry.name);
+      if (decision.state === "blocked") {
+        outcomes.push({
+          pluginId: entry.name,
+          fromVersion: entry.version,
+          toVersion: latest.version,
+          state: "skipped-blocked",
+          newCapabilities: [],
+          reason: decision.reason
+        });
+        continue;
+      }
+      const bump = semverBump(entry.version, latest.version);
+      if (!bump) continue;
+      if (!bumpAllowed(bump, p?.auto_update ?? "patch")) {
+        outcomes.push({
+          pluginId: entry.name,
+          fromVersion: entry.version,
+          toVersion: latest.version,
+          state: "skipped-policy",
+          newCapabilities: [],
+          reason: `policy is '${p?.auto_update ?? "patch"}', would not apply '${bump}' bump`
+        });
+        continue;
+      }
+      let installedCaps = [];
+      try {
+        const installedDetail = await getVersion(entry.name, entry.version);
+        installedCaps = installedDetail.manifest.capabilities.required ?? [];
+      } catch {
+      }
+      const latestCaps = latest.manifest.capabilities.required ?? [];
+      const newCaps = latestCaps.filter((c) => !installedCaps.includes(c));
+      const requireReview = p?.require_review_on_cap_growth ?? true;
+      if (newCaps.length > 0 && requireReview) {
+        outcomes.push({
+          pluginId: entry.name,
+          fromVersion: entry.version,
+          toVersion: latest.version,
+          state: "pending-review",
+          newCapabilities: newCaps,
+          reason: "new capabilities requested"
+        });
+        continue;
+      }
+      if (latest.artifact_url) {
+        installed.uninstall(entry.url);
+        installed.install(latest.artifact_url);
+        installed.updateMeta(latest.artifact_url, {
+          name: entry.name,
+          version: latest.version,
+          label: latest.manifest.name ?? entry.name,
+          description: latest.manifest.description
+        });
+      }
+      outcomes.push({
+        pluginId: entry.name,
+        fromVersion: entry.version,
+        toVersion: latest.version,
+        state: "applied",
+        newCapabilities: newCaps
+      });
+    }
+    return outcomes;
+  }
+  function capabilitiesFor(detail) {
+    const m = "manifest" in detail ? detail.manifest : detail;
+    return {
+      required: [...m.capabilities.required ?? []],
+      optional: [...m.capabilities.optional ?? []]
+    };
+  }
+  async function loadPolicy(serverUrl) {
+    const url = `${serverUrl.replace(/\/$/, "")}/plugins/policy`;
+    const fetched = await $fetch(url);
+    policy.value = fetched;
+    return fetched;
+  }
+  function policyDecisionFor(pluginId) {
+    const p = policy.value;
+    if (!p) return { state: "unknown" };
+    if (p.allowlist.includes(pluginId)) return { state: "allowed" };
+    if (p.allow_user_install) return { state: "gated" };
+    return {
+      state: "blocked",
+      reason: "Your server only permits plugins from its allowlist."
+    };
+  }
+  const categories = computed(() => {
+    const set = /* @__PURE__ */ new Set();
+    for (const p of plugins.value) for (const c of p.categories) set.add(c);
+    return [...set].sort();
+  });
+  return {
+    /** Public catalog (latest page fetched). Refresh via `list()`. */
+    plugins,
+    /** Distinct category tags across `plugins`, alphabetical. */
+    categories,
+    pagination,
+    isLoading,
+    error,
+    list,
+    get,
+    getLatest,
+    getVersion,
+    install,
+    installFromUrl,
+    isInstalled,
+    capabilitiesFor,
+    /** Current server policy. `null` until `loadPolicy()` resolves. */
+    policy,
+    loadPolicy,
+    /** Per-plugin install gate. Drives every Install button across the UI. */
+    policyDecisionFor,
+    checkUpdates
+  };
+}
+function semverBump(from, to) {
+  const a = parseSemver(from);
+  const b = parseSemver(to);
+  if (!a || !b) return null;
+  if (b.major > a.major) return "major";
+  if (b.major < a.major) return null;
+  if (b.minor > a.minor) return "minor";
+  if (b.minor < a.minor) return null;
+  if (b.patch > a.patch) return "patch";
+  return null;
+}
+function parseSemver(v) {
+  const cleaned = v.replace(/^v/, "").split(/[-+]/)[0];
+  if (!cleaned) return null;
+  const parts = cleaned.split(".").map((p) => Number.parseInt(p, 10));
+  if (parts.length !== 3 || parts.some((p) => Number.isNaN(p))) return null;
+  return { major: parts[0], minor: parts[1], patch: parts[2] };
+}
+function bumpAllowed(bump, policy) {
+  if (policy === "off") return false;
+  if (policy === "patch") return bump === "patch";
+  if (policy === "minor") return bump === "patch" || bump === "minor";
+  return true;
+}

package/dist/runtime/composables/useQuery.d.ts

@@ -0,0 +1,79 @@
+/**
+ * useQuery — query + live-subscribe to documents in the doc-tree.
+ *
+ * Two modes:
+ *
+ *   1. **Imperative (`subscribe: false`, default)** — thin Vue-reactive
+ *      shell around `client.queryDocs`. Call `refresh()` to re-fetch.
+ *      Use for "give me the matching docs right now" reads.
+ *
+ *   2. **Reactive (`subscribe: true`)** — opens a `provider.subscribeQuery`
+ *      under the hood. The first frame fills `entries`; subsequent
+ *      `delta` frames merge in via add/remove. Resubscribes when the
+ *      options ref changes; cancels on unmount.
+ *
+ * Reactive mode requires an active provider — `entries` stays empty
+ * until the provider connects and the initial snapshot arrives.
+ *
+ * Usage:
+ *
+ *     // Imperative
+ *     const { entries, loading, refresh } = useQuery({ type: 'kanban' })
+ *     await refresh()
+ *
+ *     // Reactive (mount → snapshot → live deltas → unmount cancels)
+ *     const { entries } = useQuery(
+ *       computed(() => ({ type: 'kanban', where: { priority: { gte: 3 } } })),
+ *       { immediate: true, subscribe: true },
+ *     )
+ */
+import { type Ref } from 'vue';
+import type { DocumentMeta } from '@abraca/dabra';
+export interface QueryOptions {
+    /** Match `documents.kind` exactly. */
+    type?: string;
+    /** Narrow to children of this doc. */
+    parentId?: string;
+    /** Case-insensitive substring match on `documents.label`. */
+    labelContains?: string;
+    /** Maximum number of results (default 50, hard cap 500 server-side). */
+    limit?: number;
+    /**
+     * Predicate AST. Shape mirrors `@abraca/schema`'s `WhereClause`:
+     *   `{ priority: { gte: 3 }, tags: { contains: "urgent" } }`
+     * Empty / missing falls through to the v1 filter set.
+     */
+    where?: unknown;
+}
+export interface UseQueryReturn {
+    /** Latest result set. Empty until `refresh()` runs at least once. */
+    readonly entries: Ref<readonly DocumentMeta[]>;
+    /** True while a fetch is in flight. */
+    readonly loading: Ref<boolean>;
+    /** Last error message, or null. Cleared on the next refresh. */
+    readonly error: Ref<string | null>;
+    /** Trigger a fresh fetch with the current options. */
+    refresh: () => Promise<DocumentMeta[]>;
+}
+export interface UseQueryHookOptions {
+    /**
+     * Run `refresh()` immediately when the composable mounts, and whenever
+     * the options ref changes. Default false — the caller invokes `refresh`
+     * explicitly. Note that when the options arg is a plain object (not a
+     * ref / computed), the watcher fires once at mount and then never
+     * again — change-tracking requires a reactive source.
+     */
+    immediate?: boolean;
+    /**
+     * Open a live `query:v1:` subscription on the provider's WebSocket
+     * instead of polling REST. The first `ack` frame fills `entries`;
+     * subsequent `delta` frames merge in. Cancels on unmount, and on
+     * options change (a fresh sub is opened with the new predicate).
+     *
+     * Implies `immediate: true` — subscriptions are useless without an
+     * initial snapshot. Falls back to imperative mode when no provider
+     * is bound or the WS is closed.
+     */
+    subscribe?: boolean;
+}
+export declare function useQuery(options: QueryOptions | Ref<QueryOptions>, hookOpts?: UseQueryHookOptions): UseQueryReturn;

package/dist/runtime/composables/useQuery.js

@@ -0,0 +1,97 @@
+import { onScopeDispose, ref, shallowRef, watch } from "vue";
+import { useAbracadabra } from "#imports";
+function asOptions(input) {
+  if (input.value !== void 0 && typeof input.effect !== "undefined") {
+    return input;
+  }
+  if (input.value !== void 0) {
+    return input;
+  }
+  return ref(input);
+}
+export function useQuery(options, hookOpts = {}) {
+  const opts = asOptions(options);
+  const entries = shallowRef([]);
+  const loading = ref(false);
+  const error = ref(null);
+  async function refresh() {
+    const abra = useAbracadabra();
+    const client = abra.client?.value;
+    if (!client) {
+      entries.value = [];
+      return [];
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await client.queryDocs(opts.value);
+      entries.value = Object.freeze(result.slice());
+      return result;
+    } catch (err) {
+      error.value = err instanceof Error ? err.message : String(err);
+      entries.value = [];
+      return [];
+    } finally {
+      loading.value = false;
+    }
+  }
+  let activeHandle = null;
+  function closeSubscription() {
+    if (activeHandle) {
+      activeHandle.cancel();
+      activeHandle = null;
+    }
+  }
+  function specFromOpts(o) {
+    return {
+      type: o.type,
+      parentId: o.parentId,
+      labelContains: o.labelContains,
+      limit: o.limit,
+      where: o.where
+    };
+  }
+  async function openSubscription() {
+    closeSubscription();
+    const abra = useAbracadabra();
+    const provider = abra.provider?.value;
+    if (!provider?.subscribeQuery) {
+      await refresh();
+      return;
+    }
+    loading.value = true;
+    error.value = null;
+    activeHandle = provider.subscribeQuery(specFromOpts(opts.value), {
+      onSnapshot: (rows) => {
+        entries.value = Object.freeze(rows.slice());
+        loading.value = false;
+      },
+      onDelta: ({ added, removed }) => {
+        const removedSet = new Set(removed);
+        const kept = entries.value.filter(
+          (e) => !removedSet.has(e.id)
+        );
+        const next = [...added, ...kept];
+        entries.value = Object.freeze(next);
+      },
+      onError: (err) => {
+        error.value = err.message;
+      }
+    });
+  }
+  if (hookOpts.subscribe) {
+    watch(
+      opts,
+      () => {
+        void openSubscription();
+      },
+      { immediate: true, deep: true }
+    );
+    onScopeDispose(() => closeSubscription());
+  } else if (hookOpts.immediate) {
+    watch(opts, () => {
+      void refresh();
+    }, { immediate: true, deep: true });
+  }
+  return { entries, loading, error, refresh };
+}

package/dist/runtime/composables/useSpaces.js

@@ -1,5 +1,4 @@
 import { ref, computed } from "vue";
-import { useRoute } from "#imports";
 import { useAbracadabra } from "./useAbracadabra.js";
 const loading = ref(false);
 const error = ref(null);
@@ -7,10 +6,10 @@ export function useSpaces() {
   const abra = useAbracadabra();
   const spaces = computed(() => abra.currentServerSpaces.value ?? []);
   const currentSpace = computed(() => {
-    const route = useRoute();
-    const docId = route.params.docId;
-    if (!docId) return spaces.value[0] ?? null;
-    return spaces.value.find((s) => s.id === docId) ?? null;
+    const entry = abra.savedServers?.value?.find?.((s) => s.url === abra.currentServerUrl?.value);
+    const entryDocId = entry?.entryDocId;
+    if (!entryDocId) return spaces.value[0] ?? null;
+    return spaces.value.find((s) => s.doc_id === entryDocId) ?? spaces.value[0] ?? null;
   });
   async function refresh() {
     loading.value = true;

package/dist/runtime/composables/useTableView.d.ts

@@ -5,9 +5,9 @@ export declare function useTableView(tree: {
     treeMap: any;
 }, tableDocId: string): {
     tableMeta: import("vue").ComputedRef<DocPageMeta>;
-    explicitMode: import("vue").ComputedRef<"flat" | "hierarchy" | undefined>;
-    detectedMode: import("vue").ComputedRef<"flat" | "hierarchy">;
-    effectiveMode: import("vue").ComputedRef<"flat" | "hierarchy">;
+    explicitMode: import("vue").ComputedRef<"hierarchy" | "flat" | undefined>;
+    detectedMode: import("vue").ComputedRef<"hierarchy" | "flat">;
+    effectiveMode: import("vue").ComputedRef<"hierarchy" | "flat">;
     setMode: (mode: "hierarchy" | "flat" | undefined) => void;
     columnDefs: import("vue").ComputedRef<TableColumnDef[]>;
     addColumn: (def: TableColumnDef) => void;

package/dist/runtime/composables/useTypedDoc.d.ts

@@ -0,0 +1,97 @@
+/**
+ * useTypedDoc — typed reads + validated writes against the Abracadabra
+ * doc-tree, parameterised by a `@abraca/schema` registry.
+ *
+ * Day 2 of the Phase 3 schema rollout.
+ *
+ * The Nuxt module reads / writes the doc-tree through `useSyncedMap` on
+ * the root Y.Doc — it does NOT use `DocumentManager.docs(...)` from
+ * `@abraca/dabra`, because the module instantiates `AbracadabraProvider`
+ * directly (no DM wrapper). This composable is the Nuxt-side analogue:
+ * a typed projection over `useDocTree`'s reactive entries, with optional
+ * pre-write validation against the supplied registry.
+ *
+ *     // app code
+ *     import { kanbanSchema } from '@abraca/schema'
+ *     const { get, all, update } = useTypedDoc(kanbanSchema)
+ *     const board = computed(() => get('kanban', boardId.value))
+ *     // board.value?.meta.kanbanColumnWidth is typed
+ *     update('kanban', boardId.value, { kanbanColumnWidth: 'wide' })
+ *
+ * Behaviour:
+ *  - `get(type, id)` returns null when the entry is missing OR its
+ *    stored `type` doesn't match (cross-schema reads return null —
+ *    matches the server-side smoke contract).
+ *  - `update(type, id, patch)` validates the *merged* meta before
+ *    writing. Throws `MetaValidationError`-equivalent on mismatch.
+ *  - `set(type, id, meta)` validates the replacement meta.
+ *  - `clear(type, id, keys)` is a thin wrapper over `updateMeta` —
+ *    no validation (clearing keys can never fail validation).
+ *  - Reads do NOT auto-call `runMigrations`. Pass `migrate: true` in
+ *    the per-call options or use `useDocEntryTyped` (Day 3).
+ *
+ * Type inference: when a typed `SchemaRegistry<TMap>` is passed, every
+ * read/write narrows `meta` to `TMap[N]`. Untyped registries fall back
+ * to `Record<string, unknown>`.
+ */
+import { type ComputedRef } from 'vue';
+import type { SchemaRegistryLike } from '../utils/schemaSupport.js';
+/** Extract the doc-type names from a typed registry. */
+type SchemaDocTypeName<S> = S extends {
+    __metaMap?: infer M;
+} ? keyof M & string : string;
+/** Extract the meta type for a given doc-type name from a registry. */
+type SchemaMetaOf<S, N extends string> = S extends {
+    __metaMap?: infer M;
+} ? N extends keyof M ? M[N] : Record<string, unknown> : Record<string, unknown>;
+export interface TypedTreeEntry<M> {
+    readonly id: string;
+    readonly type: string;
+    readonly label: string;
+    readonly parentId: string | null;
+    readonly order: number;
+    readonly meta: M | undefined;
+    readonly createdAt: number | undefined;
+    readonly updatedAt: number | undefined;
+}
+/**
+ * Thrown by typed write methods when validation fails.
+ *
+ * Mirrors `MetaValidationError` from `@abraca/dabra` — kept module-local
+ * because the Nuxt write path doesn't go through `MetaManager`.
+ * Consumers can `import { MetaValidationError } from '@abraca/nuxt'` to
+ * type-narrow without dragging in `@abraca/dabra`.
+ */
+export declare class MetaValidationError extends Error {
+    readonly docId: string;
+    readonly docType: string;
+    readonly errors: ReadonlyArray<{
+        path: ReadonlyArray<PropertyKey>;
+        message: string;
+        code?: string;
+    }>;
+    constructor(docId: string, docType: string, errors: ReadonlyArray<{
+        path: ReadonlyArray<PropertyKey>;
+        message: string;
+        code?: string;
+    }>);
+}
+export declare class TypedDocTypeMismatchError extends Error {
+    readonly docId: string;
+    readonly expectedType: string;
+    readonly actualType: string | undefined;
+    constructor(docId: string, expectedType: string, actualType: string | undefined);
+}
+export declare function useTypedDoc<S extends SchemaRegistryLike>(schema: S): {
+    /** Synchronous typed read. Returns null on missing entry or type mismatch. */
+    get: <N extends SchemaDocTypeName<S>>(type: N, id: string) => TypedTreeEntry<SchemaMetaOf<S, N>> | null;
+    /** Reactive list of every entry whose stored `type` matches `type`. */
+    all: <N extends SchemaDocTypeName<S>>(type: N) => ComputedRef<TypedTreeEntry<SchemaMetaOf<S, N>>[]>;
+    /** Validated meta merge. Throws on mismatch / validation failure. */
+    update: <N extends SchemaDocTypeName<S>>(type: N, id: string, patch: Partial<SchemaMetaOf<S, N>>) => void;
+    /** Validated meta replacement. Throws on mismatch / validation failure. */
+    set: <N extends SchemaDocTypeName<S>>(type: N, id: string, meta: SchemaMetaOf<S, N>) => void;
+    /** Delete specific keys. No validation (clearing can't fail validation). */
+    clear: <N extends SchemaDocTypeName<S>>(type: N, id: string, keys: ReadonlyArray<keyof SchemaMetaOf<S, N> & string>) => void;
+};
+export {};

package/dist/runtime/composables/useTypedDoc.js

@@ -0,0 +1,114 @@
+import { computed } from "vue";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { useDocTree } from "./useDocTree.js";
+export class MetaValidationError extends Error {
+  docId;
+  docType;
+  errors;
+  constructor(docId, docType, errors) {
+    super(
+      `meta validation failed for doc ${docId} (type "${docType}"): ` + errors.map((e) => `${e.path.join(".") || "<root>"}: ${e.message}`).join("; ")
+    );
+    this.name = "MetaValidationError";
+    this.docId = docId;
+    this.docType = docType;
+    this.errors = errors;
+  }
+}
+export class TypedDocTypeMismatchError extends Error {
+  docId;
+  expectedType;
+  actualType;
+  constructor(docId, expectedType, actualType) {
+    super(
+      `typed write on document ${docId} expected type "${expectedType}" but stored type is ` + (actualType === void 0 ? "(none)" : `"${actualType}"`)
+    );
+    this.name = "TypedDocTypeMismatchError";
+    this.docId = docId;
+    this.expectedType = expectedType;
+    this.actualType = actualType;
+  }
+}
+function projectEntry(entry, expectedType) {
+  if (!entry) return null;
+  if (entry.type !== expectedType) return null;
+  return {
+    id: entry.id,
+    type: expectedType,
+    label: entry.label,
+    parentId: entry.parentId,
+    order: entry.order,
+    meta: entry.meta,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt
+  };
+}
+export function useTypedDoc(schema) {
+  const abra = useAbracadabra();
+  const tree = useDocTree();
+  function readEntry(id) {
+    return tree.getEntry(id);
+  }
+  function ensureType(id, expectedType) {
+    const entry = readEntry(id);
+    if (!entry) {
+      throw new TypedDocTypeMismatchError(id, expectedType, void 0);
+    }
+    if (entry.type !== expectedType) {
+      throw new TypedDocTypeMismatchError(id, expectedType, entry.type);
+    }
+    return entry;
+  }
+  function validateOrThrow(id, type, meta) {
+    const result = schema.validateMeta(type, meta);
+    if (result.ok) return result.value ?? meta;
+    throw new MetaValidationError(id, type, result.errors);
+  }
+  function writeMeta(id, nextMeta) {
+    const doc = abra.doc.value;
+    if (!doc) return;
+    const treeMap = doc.getMap("doc-tree");
+    const entry = treeMap.get(id);
+    if (!entry) return;
+    treeMap.set(id, {
+      ...entry,
+      meta: nextMeta,
+      updatedAt: Date.now()
+    });
+  }
+  return {
+    get(type, id) {
+      return projectEntry(readEntry(id), type);
+    },
+    all(type) {
+      return computed(
+        () => tree.entries.value.filter((e) => e.type === type && !e.trashed).map((e) => projectEntry(e, type)).filter((e) => e !== null)
+      );
+    },
+    update(type, id, patch) {
+      const entry = ensureType(id, type);
+      const merged = {
+        ...entry.meta ?? {},
+        ...patch
+      };
+      validateOrThrow(id, type, merged);
+      writeMeta(id, merged);
+    },
+    set(type, id, meta) {
+      ensureType(id, type);
+      validateOrThrow(id, type, meta);
+      writeMeta(id, meta);
+    },
+    clear(type, id, keys) {
+      const entry = ensureType(id, type);
+      if (!entry.meta) return;
+      const src = entry.meta;
+      const dropped = new Set(keys.map((k) => k));
+      const next = {};
+      for (const [k, v] of Object.entries(src)) {
+        if (!dropped.has(k)) next[k] = v;
+      }
+      writeMeta(id, next);
+    }
+  };
+}