@ai-matrx/records 0.96.14 → 0.97.1

package/dist/setup/index.d.cts

@@ -1,5 +1,5 @@
 import { RealtimeManager } from '@ai-matrx/realtime';
-import { R as RecordsClient } from '../client-DKgbZUNt.cjs';
+import { R as RecordsClient } from '../client-pFV_8AhM.cjs';
 import { C as CreateEntityDataPortOptions, E as EntityDataPort } from '../port-CEf9hsW4.cjs';
 import { R as RecordOrganizationPort, O as ObjectOrganizationAnswer } from '../objectOrganization-CDAoE7Ft.cjs';
 import { a as RecordsConfig, b as RowAgentPort, c as RecordsErrorSink, d as RecordsDataSource, e as RecordsChangeSink, f as RowAgentTarget } from '../ports-DEkN-WfA.cjs';
@@ -10,6 +10,7 @@ import '../field-DjS7iId2.cjs';
 import '../subscription-ycCVo9e2.cjs';
 import '../rule-CbBXN-FW.cjs';
 import '../relation-BbPDcXp5.cjs';
+import '../doors-CJPHsohF.cjs';
 import '../portal-CUwIsXsx.cjs';
 import '../types-Dxc8Pt7Y.cjs';
 

package/dist/setup/index.d.ts

@@ -1,5 +1,5 @@
 import { RealtimeManager } from '@ai-matrx/realtime';
-import { R as RecordsClient } from '../client-D7bvxEZW.js';
+import { R as RecordsClient } from '../client-MVuEbxKl.js';
 import { C as CreateEntityDataPortOptions, E as EntityDataPort } from '../port-BNXXJINy.js';
 import { R as RecordOrganizationPort, O as ObjectOrganizationAnswer } from '../objectOrganization-IBxZqFZQ.js';
 import { a as RecordsConfig, b as RowAgentPort, c as RecordsErrorSink, d as RecordsDataSource, e as RecordsChangeSink, f as RowAgentTarget } from '../ports-YOhD5T7h.js';
@@ -10,6 +10,7 @@ import '../field-D-1OKy5r.js';
 import '../subscription-DucBLG-Y.js';
 import '../rule-BVX1C83I.js';
 import '../relation-Dk9-VzY0.js';
+import '../doors-C43_5HjC.js';
 import '../portal-DDOmQR1f.js';
 import '../types-Du4Q9Rvi.js';
 

package/dist/setup/index.js

@@ -418,6 +418,639 @@ function createOpLedger() {
 }
 var defaultOpLedger = ledgerOver(globalSlot2("ai-matrx.records.op-ledger", () => /* @__PURE__ */ new Map()));
 
+// src/scopes/codec.ts
+var str = (v, fallback = "") => typeof v === "string" ? v : fallback;
+var strOrNull = (v) => typeof v === "string" ? v : null;
+var num = (v, fallback = 0) => {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+  return Number.isFinite(n) ? n : fallback;
+};
+function scopeTypeFromStore(row) {
+  const singular = row.label_singular ?? row.name ?? "";
+  return {
+    id: row.id,
+    organization_id: row.organization_id,
+    label_singular: singular,
+    label_plural: row.label_plural ?? singular,
+    icon: row.icon ?? "folder",
+    color: row.color ?? "",
+    slug: row.slug ?? null,
+    description: row.description ?? "",
+    sort_order: num(row.sort_order),
+    max_assignments_per_entity: row.max_assignments_per_entity ?? null,
+    default_variable_keys: Array.isArray(row.default_variable_keys) ? row.default_variable_keys : [],
+    created_by: row.created_by ?? null,
+    created_at: row.created_at ?? "",
+    updated_at: row.updated_at ?? ""
+  };
+}
+function scopeTypeLabelFromStore(t) {
+  const singular = t.label_singular ?? t.name ?? "";
+  return { id: t.id, label_singular: singular, label_plural: t.label_plural ?? singular, icon: t.icon ?? null, color: t.color ?? null };
+}
+function settingFromStore(value) {
+  if (!Array.isArray(value)) return value;
+  return value.map((el) => {
+    if (typeof el !== "string") return el;
+    const t = el.trim();
+    if (!(t.startsWith("{") && t.endsWith("}")) && !(t.startsWith("[") && t.endsWith("]"))) return el;
+    try {
+      return JSON.parse(t);
+    } catch {
+      return el;
+    }
+  });
+}
+function scopeFromStore(row) {
+  const settings = {};
+  for (const [k, v] of Object.entries(row.settings ?? {})) settings[k] = settingFromStore(v);
+  return {
+    id: row.id,
+    scope_type_id: row.scope_type_id,
+    organization_id: row.organization_id,
+    name: row.name ?? "",
+    description: row.description ?? "",
+    slug: row.slug ?? null,
+    sort_order: num(row.sort_order),
+    parent_scope_id: row.parent_scope_id ?? null,
+    settings,
+    created_by: row.created_by ?? null,
+    created_at: row.created_at ?? "",
+    updated_at: row.updated_at ?? ""
+  };
+}
+function scopeWithTypeFromStore(row) {
+  return { ...scopeFromStore(row), scope_type: row.scope_type ? scopeTypeLabelFromStore(row.scope_type) : null };
+}
+function archivedScopeTypeFromStore(row) {
+  const singular = row.label_singular ?? "";
+  return {
+    id: row.id,
+    organization_id: row.organization_id,
+    label_singular: singular,
+    label_plural: row.label_plural ?? singular,
+    icon: row.icon ?? "folder",
+    color: row.color ?? "",
+    archived_at: row.deleted_at ?? "",
+    created_by: row.created_by ?? null,
+    archived_scope_count: row.archived_scope_count ?? 0
+  };
+}
+var FILE_KERNEL_ID = "11111111-0000-4000-8000-000000000006";
+var KINDS = /* @__PURE__ */ new Set([
+  "string",
+  "markdown",
+  "email",
+  "url",
+  "phone",
+  "color",
+  "number",
+  "percent",
+  "currency",
+  "boolean",
+  "date",
+  "datetime",
+  "time",
+  "object",
+  "array",
+  "reference",
+  "document"
+]);
+function contextFieldKind(doc, carried) {
+  if (carried?.as_text && carried.value_type && KINDS.has(carried.value_type)) return carried.value_type;
+  const behavior = String(doc.type ?? "text");
+  const fmt = doc.format ? String(doc.format) : "";
+  const shown = doc.display_format && typeof doc.display_format === "object" ? String(doc.display_format.id ?? "") : "";
+  const kind = String(doc.config?.kind ?? "");
+  const multi = Boolean(doc.multi);
+  if (behavior === "boolean") return "boolean";
+  if (behavior === "relation") return doc.relation_target === FILE_KERNEL_ID && !multi ? "document" : "reference";
+  if (behavior === "range") {
+    if (kind === "date") return "date";
+    if (kind === "datetime") return "datetime";
+    if (fmt === "percent" || fmt === "currency") return fmt;
+    return "number";
+  }
+  if (behavior === "text") {
+    if (multi) return "array";
+    if (fmt === "json") return "object";
+    for (const word of [fmt, shown]) {
+      if (word === "time" || word === "email" || word === "url" || word === "phone" || word === "color" || word === "markdown") return word;
+    }
+  }
+  return "string";
+}
+var POLICIES = /* @__PURE__ */ new Set(["include", "on_request", "exclude"]);
+var SENSITIVITIES = /* @__PURE__ */ new Set(["public", "internal", "confidential", "restricted"]);
+function contextFieldFromStore(row) {
+  const d = row.data ?? {};
+  const key = str(d.key);
+  const policy = str(d.context_policy, "include");
+  const sensitivity = str(d.sensitivity, "internal");
+  return {
+    id: row.id,
+    scope_type_id: row.scope_type_id,
+    organization_id: row.organization_id,
+    key,
+    label: str(d.label, key),
+    description: str(d.description),
+    kind: contextFieldKind(d, row.carried),
+    type: str(d.type, "text"),
+    multi: Boolean(d.multi),
+    format: strOrNull(d.format),
+    config: d.config ?? {},
+    relation_target: strOrNull(d.relation_target),
+    // The store's sort counts the scope's own two columns first (custom._ctx_store_item: + 2).
+    sort: Math.max(0, num(d.sort) - 2),
+    context_policy: POLICIES.has(policy) ? policy : "include",
+    sensitivity: SENSITIVITIES.has(sensitivity) ? sensitivity : "internal",
+    source: str(d.source, "manual"),
+    status: str(d.status, "active"),
+    status_note: strOrNull(d.status_note),
+    category: strOrNull(d.category),
+    tags: Array.isArray(d.tags) ? d.tags : [],
+    max_items: typeof d.max_items === "number" ? d.max_items : 1,
+    custom_component: d.custom_component ?? null,
+    reference_source: d.reference_source ?? null,
+    allowed_scope_type_ids: Array.isArray(d.allowed_scope_type_ids) ? d.allowed_scope_type_ids : null,
+    allowed_reference_types: Array.isArray(d.allowed_reference_types) ? d.allowed_reference_types : null,
+    review_interval_days: typeof d.review_interval_days === "number" ? d.review_interval_days : null,
+    depends_on: Array.isArray(d.depends_on) ? d.depends_on : [],
+    version: num(row.version, 1),
+    created_by: row.created_by ?? null,
+    created_at: row.created_at ?? "",
+    updated_at: row.updated_at ?? ""
+  };
+}
+var POLICY_TO_DOOR = { include: "always", on_request: "on_demand", exclude: "never" };
+var SENSITIVITY_TO_DOOR = {
+  public: "public",
+  internal: "internal",
+  confidential: "restricted",
+  restricted: "privileged"
+};
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function referencesOf(row) {
+  const v = row.value;
+  const list = Array.isArray(v) ? v : v == null ? [] : [v];
+  const labels = row.labels ?? {};
+  const files = row.files ?? {};
+  const toFile = row.field?.relation_target === FILE_KERNEL_ID;
+  const out = [];
+  for (const el of list) {
+    let ref = null;
+    if (typeof el === "string" && UUID.test(el)) ref = { id: el, type: toFile ? "file" : "scope" };
+    else if (el && typeof el === "object" && typeof el.id === "string") {
+      const token = String(el.token ?? "");
+      const own = el.label;
+      ref = { id: el.id, type: token === "dataset" ? "table" : token || (toFile ? "file" : "scope") };
+      if (typeof own === "string" && own) ref.label = own;
+    }
+    if (!ref) continue;
+    const label = labels[ref.id];
+    if (label) ref.label = label;
+    const fileId = files[ref.id];
+    if (fileId) ref.file_id = fileId;
+    out.push(ref);
+  }
+  return out;
+}
+function contextValueFromStore(row) {
+  const kind = contextFieldKind(row.field ?? {}, row.field?.carried);
+  const carriedText = Boolean(row.field?.carried?.as_text);
+  const isRef2 = !carriedText && (kind === "reference" || kind === "document");
+  return {
+    scope_id: row.scope_id,
+    field_id: row.context_item_id,
+    key: row.key,
+    kind,
+    value: row.value ?? null,
+    references: isRef2 ? referencesOf(row) : [],
+    version: num(row.version, 1),
+    set_at: row.set_at ?? null,
+    source_type: row.source_type ?? null,
+    authored_by: row.authored_by ?? null,
+    whole_value: row.whole_value ?? null,
+    incomplete: null
+  };
+}
+async function sha256Hex(text) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) return null;
+  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function completeWholeValues(values, read) {
+  const texts = /* @__PURE__ */ new Map();
+  await Promise.all(
+    values.map(async (cell) => {
+      const w = cell.whole_value;
+      if (!w || w.in_value || typeof cell.value !== "string") return;
+      const head = cell.value;
+      const chars = typeof w.chars === "number" ? w.chars : null;
+      const incomplete = (fileId, why) => {
+        cell.incomplete = { head, chars, file_id: fileId, why };
+      };
+      if (!w.file_id) return incomplete(null, "The rest of this text is still being saved.");
+      if (!read) return incomplete(w.file_id, "This place cannot open the file that holds the whole text.");
+      if (!texts.has(w.file_id)) texts.set(w.file_id, read(w.file_id));
+      try {
+        const text = await texts.get(w.file_id);
+        if (chars !== null && [...text].length !== chars) {
+          return incomplete(w.file_id, `The file holds ${[...text].length} characters, not ${chars}.`);
+        }
+        if (w.sha256) {
+          const sha = await sha256Hex(text);
+          if (sha === null) return incomplete(w.file_id, "This browser cannot check the file.");
+          if (sha !== w.sha256) return incomplete(w.file_id, "The file's content is not the text the cell points at.");
+        }
+        cell.value = text;
+      } catch (thrown) {
+        incomplete(w.file_id, thrown instanceof Error ? thrown.message : String(thrown));
+      }
+    })
+  );
+}
+function definedOnly(fields) {
+  const out = {};
+  for (const [k, v] of Object.entries(fields)) if (v !== void 0) out[k] = v;
+  return out;
+}
+function fieldSpecForDoor(spec) {
+  return definedOnly({
+    key: spec.key,
+    display_name: spec.label,
+    value_type: spec.kind,
+    description: spec.description,
+    category: spec.category,
+    fetch_hint: spec.context_policy ? POLICY_TO_DOOR[spec.context_policy] : void 0,
+    sensitivity: spec.sensitivity ? SENSITIVITY_TO_DOOR[spec.sensitivity] : void 0,
+    tags: spec.tags,
+    sort_order: spec.sort,
+    status: spec.status,
+    status_note: spec.status_note,
+    custom_component: spec.custom_component,
+    review_interval_days: spec.review_interval_days,
+    allowed_reference_types: spec.allowed_reference_types,
+    max_items: spec.max_items,
+    allowed_scope_type_ids: spec.allowed_scope_type_ids,
+    reference_source: spec.reference_source
+  });
+}
+function referenceFence(references) {
+  const kinds = [...new Set(references.map((r) => r.type))];
+  const type = kinds.length === 1 ? kinds[0] : "mixed";
+  const items = references.map((r) => {
+    if (r.type === "file" && r.file_id) return r.label ? { file_id: r.file_id, label: r.label } : { file_id: r.file_id };
+    const item = { id: r.id };
+    if (r.label) item.label = r.label;
+    if (kinds.length > 1) item.type = r.type;
+    return item;
+  });
+  return "```matrx\n" + JSON.stringify({ matrx_version: 1, kind: "reference", type, items }, null, 2) + "\n```";
+}
+function valuePayloadForDoor(write) {
+  const base = definedOnly({
+    scope_id: write.scope_id,
+    context_item_id: write.field_id,
+    source_type: write.source_type,
+    change_summary: write.change_summary
+  });
+  const v = write.value;
+  if (write.kind === "reference" || write.kind === "document") {
+    if (write.references) return { ...base, value_text: write.references.length ? referenceFence(write.references) : null };
+    if (write.kind === "document" && typeof v === "string") return { ...base, value_document_url: v || null };
+    return { ...base, value_text: typeof v === "string" ? v || null : null };
+  }
+  if (v === null || v === void 0 || v === "") {
+    return { ...base, value_text: null };
+  }
+  switch (write.kind) {
+    case "number":
+    case "percent":
+      return typeof v === "number" ? { ...base, value_number: v } : { ...base, value_text: String(v) };
+    case "currency":
+      return typeof v === "object" ? { ...base, value_json: v } : typeof v === "number" ? { ...base, value_number: v } : { ...base, value_text: String(v) };
+    case "boolean":
+      return typeof v === "boolean" ? { ...base, value_boolean: v } : { ...base, value_text: String(v) };
+    case "date":
+      return { ...base, value_date: String(v) };
+    case "datetime":
+      return { ...base, value_timestamp: String(v) };
+    case "time":
+      return { ...base, value_time: String(v) };
+    case "object":
+    case "array":
+      return typeof v === "object" ? { ...base, value_json: v } : { ...base, value_text: String(v) };
+    default:
+      return typeof v === "object" ? { ...base, value_json: v } : { ...base, value_text: String(v) };
+  }
+}
+
+// src/scopes/rules.ts
+function toSlug(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isValidSlug(s) {
+  return /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/.test(s);
+}
+var RESERVED_SCOPE_SLUGS = /* @__PURE__ */ new Set(["context-items", "scopes", "edit", "manage", "new", "settings"]);
+function isReservedSlug(s) {
+  return RESERVED_SCOPE_SLUGS.has(s.toLowerCase().replace(/_/g, "-"));
+}
+function resolveSlug(supplied, fallbackName) {
+  const slug = supplied?.trim() || toSlug(fallbackName);
+  if (!slug || !isValidSlug(slug)) {
+    return {
+      ok: false,
+      error: { code: "invalid_argument", message: "Use letters, numbers and single hyphens for the short name." }
+    };
+  }
+  if (isReservedSlug(slug)) {
+    return { ok: false, error: { code: "invalid_argument", message: `"${slug}" is a page name here. Pick another short name.` } };
+  }
+  return { ok: true, data: slug };
+}
+
+// src/scopes/doors.ts
+var SCOPES_PER_CALL = 500;
+var SCOPE_TYPES_PER_FIELDS_CALL = 100;
+var SCOPES_PER_VALUES_CALL = 200;
+var TYPE_SCOPES_PAGE = 200;
+var ARCHIVED_SCOPES_PAGE = 200;
+var uniq = (ids) => [...new Set(ids.filter(Boolean))];
+async function inBatches(ids, size, call) {
+  const unique = uniq(ids);
+  const batches = [];
+  for (let i = 0; i < unique.length; i += size) batches.push(unique.slice(i, i + size));
+  const answers = await Promise.all(batches.map(call));
+  const out = [];
+  for (const a of answers) {
+    if (!a.ok) return a;
+    out.push(...a.data ?? []);
+  }
+  return { ok: true, data: out };
+}
+function noRow(door) {
+  return { ok: false, error: { code: "internal", message: `${door} answered without the row it wrote.`, diagnostic: `@ai-matrx/records/scopes: ${door}` } };
+}
+var VALUE_DOOR_CODES = {
+  unauthorized: "door",
+  forbidden: "door",
+  forbidden_org: "door",
+  not_found: "not_found",
+  invalid_argument: "invalid_argument",
+  conflict: "stale_write",
+  unavailable: "not_supported"
+};
+function createScopeDoors(call) {
+  async function write(door, args) {
+    const res = await call(door, args, `scopes.${door}`);
+    if (!res.ok) return res;
+    const row = res.data?.row;
+    if (!row || typeof row !== "object") return noRow(door);
+    return { ok: true, data: row };
+  }
+  async function archiveOrRestore(door, args, id) {
+    const res = await call(door, args, `scopes.${door}`);
+    return res.ok ? { ok: true, data: { id } } : res;
+  }
+  async function fieldById(scopeTypeId, fieldId, door) {
+    const fields = await doors.fields([scopeTypeId]);
+    if (!fields.ok) return fields;
+    const field = fields.data.find((f) => f.id === fieldId);
+    return field ? { ok: true, data: field } : noRow(door);
+  }
+  const doors = {
+    async tree(organizationIds) {
+      const ids = uniq(organizationIds);
+      if (ids.length === 0) return { ok: true, data: [] };
+      const res = await call("context_tree", { p_organization_ids: ids }, "scopes.tree");
+      if (!res.ok) return res;
+      const byType = /* @__PURE__ */ new Map();
+      for (const s of res.data?.scopes ?? []) {
+        const scope = scopeFromStore(s);
+        const list = byType.get(scope.scope_type_id) ?? [];
+        list.push(scope);
+        byType.set(scope.scope_type_id, list);
+      }
+      return { ok: true, data: (res.data?.types ?? []).map((t) => ({ ...scopeTypeFromStore(t), scopes: byType.get(t.id) ?? [] })) };
+    },
+    async types(organizationIds, options) {
+      const withCounts = options?.withCounts ?? true;
+      const ids = uniq(organizationIds);
+      if (ids.length === 0) return { ok: true, data: { types: [], counts: withCounts ? {} : null } };
+      const res = await call("context_tree_types", { p_organization_ids: ids, p_with_counts: withCounts }, "scopes.types");
+      if (!res.ok) return res;
+      const rows = res.data?.types ?? [];
+      const counts = withCounts ? {} : null;
+      if (counts) for (const r of rows) counts[r.id] = Number(r.scope_count ?? 0);
+      return { ok: true, data: { types: rows.map(scopeTypeFromStore), counts } };
+    },
+    async typeScopesPage(scopeTypeId, offset = 0, limit = TYPE_SCOPES_PAGE) {
+      const res = await call(
+        "context_tree_type_scopes",
+        { p_scope_type_id: scopeTypeId, p_offset: offset, p_limit: limit },
+        "scopes.typeScopesPage"
+      );
+      if (!res.ok) return res;
+      return {
+        ok: true,
+        data: { scopes: (res.data?.scopes ?? []).map(scopeFromStore), total: Number(res.data?.total ?? 0), next_offset: res.data?.next_offset ?? null }
+      };
+    },
+    async search(organizationIds, query, limit = 100) {
+      const ids = uniq(organizationIds);
+      const q = query.trim();
+      if (ids.length === 0 || q === "") return { ok: true, data: { scopes: [], total: 0 } };
+      const res = await call(
+        "context_tree_search",
+        { p_organization_ids: ids, p_query: q, p_limit: limit },
+        "scopes.search"
+      );
+      if (!res.ok) return res;
+      return { ok: true, data: { scopes: (res.data?.scopes ?? []).map(scopeFromStore), total: Number(res.data?.total ?? 0) } };
+    },
+    async scopes(ids) {
+      const res = await inBatches(ids, SCOPES_PER_CALL, (batch) => call("context_scopes", { p_scope_ids: batch }, "scopes.scopes"));
+      return res.ok ? { ok: true, data: res.data.map(scopeWithTypeFromStore) } : res;
+    },
+    async fields(scopeTypeIds) {
+      const res = await inBatches(
+        scopeTypeIds,
+        SCOPE_TYPES_PER_FIELDS_CALL,
+        (batch) => call("context_items", { p_scope_type_ids: batch }, "scopes.fields")
+      );
+      return res.ok ? { ok: true, data: res.data.map(contextFieldFromStore) } : res;
+    },
+    async values(scopeIds, options) {
+      const res = await inBatches(
+        scopeIds,
+        SCOPES_PER_VALUES_CALL,
+        (batch) => call("context_values", { p_scope_ids: batch }, "scopes.values")
+      );
+      if (!res.ok) return res;
+      const cells = res.data.map(contextValueFromStore);
+      await completeWholeValues(cells, options?.readFileText ?? null);
+      return { ok: true, data: cells };
+    },
+    async archivedTypes(organizationId) {
+      const res = await call("context_archived_types", { p_organization_id: organizationId }, "scopes.archivedTypes");
+      return res.ok ? { ok: true, data: (res.data ?? []).map(archivedScopeTypeFromStore) } : res;
+    },
+    async archivedScopesOfType(organizationId, scopeTypeId, wanted) {
+      const out = [];
+      for (let offset = 0; out.length < wanted.size; offset += ARCHIVED_SCOPES_PAGE) {
+        const res = await call(
+          "read_records_archived",
+          { p_organization_id: organizationId, p_table_id: scopeTypeId, p_lane: "org", p_by_id: false, p_limit: ARCHIVED_SCOPES_PAGE, p_offset: offset },
+          "scopes.archivedScopesOfType"
+        );
+        if (!res.ok) return res;
+        const rows = res.data ?? [];
+        for (const r of rows) {
+          if (!wanted.has(r.id)) continue;
+          out.push({
+            id: r.id,
+            name: typeof r.document?.name === "string" ? r.document.name : null,
+            slug: typeof r.document?.slug === "string" ? r.document.slug : null,
+            archived_at: r.archived_at ?? null
+          });
+        }
+        if (rows.length < ARCHIVED_SCOPES_PAGE) break;
+      }
+      return { ok: true, data: out };
+    },
+    async systemItems() {
+      const res = await call("context_system_items", {}, "scopes.systemItems");
+      return res.ok ? { ok: true, data: res.data ?? [] } : res;
+    },
+    async templates() {
+      const res = await call("context_templates", {}, "scopes.templates");
+      return res.ok ? { ok: true, data: res.data ?? [] } : res;
+    },
+    async createType(organizationId, spec) {
+      const slug = resolveSlug(spec.slug, spec.label_plural || spec.label_singular || "");
+      if (!slug.ok) return slug;
+      const res = await write("context_type_write", {
+        p_organization_id: organizationId,
+        p_type_id: null,
+        p_spec: definedOnly({
+          label_singular: spec.label_singular,
+          label_plural: spec.label_plural,
+          icon: spec.icon ?? "folder",
+          description: spec.description ?? "",
+          sort_order: spec.sort_order ?? 0,
+          max_assignments: spec.max_assignments_per_entity ?? void 0,
+          default_variable_keys: spec.default_variable_keys ?? [],
+          color: spec.color,
+          slug: slug.data
+        })
+      });
+      return res.ok ? { ok: true, data: scopeTypeFromStore(res.data) } : res;
+    },
+    async updateType(typeId, spec) {
+      let slug;
+      if (spec.slug !== void 0) {
+        const resolved = resolveSlug(spec.slug, spec.label_plural ?? spec.label_singular ?? "");
+        if (!resolved.ok) return resolved;
+        slug = resolved.data;
+      }
+      const res = await write("context_type_write", {
+        p_organization_id: null,
+        p_type_id: typeId,
+        p_spec: definedOnly({
+          label_singular: spec.label_singular,
+          label_plural: spec.label_plural,
+          icon: spec.icon,
+          description: spec.description,
+          sort_order: spec.sort_order,
+          max_assignments: spec.max_assignments_per_entity,
+          color: spec.color,
+          slug
+        })
+      });
+      return res.ok ? { ok: true, data: scopeTypeFromStore(res.data) } : res;
+    },
+    archiveType: (typeId) => archiveOrRestore("context_type_archive", { p_type_id: typeId }, typeId),
+    restoreType: (typeId) => archiveOrRestore("context_type_restore", { p_type_id: typeId }, typeId),
+    async createScope(organizationId, typeId, spec) {
+      const slug = resolveSlug(spec.slug, spec.name ?? "");
+      if (!slug.ok) return slug;
+      const res = await write("context_scope_write", {
+        p_organization_id: organizationId,
+        p_scope_id: null,
+        p_type_id: typeId,
+        p_spec: definedOnly({
+          name: spec.name,
+          parent_scope_id: spec.parent_scope_id,
+          description: spec.description ?? "",
+          settings: spec.settings ?? {},
+          slug: slug.data,
+          sort_order: spec.sort_order
+        })
+      });
+      return res.ok ? { ok: true, data: scopeFromStore(res.data) } : res;
+    },
+    async updateScope(scopeId, spec) {
+      let slug;
+      if (spec.slug !== void 0) {
+        const resolved = resolveSlug(spec.slug, spec.name ?? "");
+        if (!resolved.ok) return resolved;
+        slug = resolved.data;
+      }
+      const res = await write("context_scope_write", {
+        p_organization_id: null,
+        p_scope_id: scopeId,
+        p_type_id: null,
+        p_spec: definedOnly({ name: spec.name, description: spec.description, settings: spec.settings, slug, sort_order: spec.sort_order })
+      });
+      return res.ok ? { ok: true, data: scopeFromStore(res.data) } : res;
+    },
+    archiveScope: (scopeId) => archiveOrRestore("context_scope_archive", { p_scope_id: scopeId }, scopeId),
+    restoreScope: (scopeId) => archiveOrRestore("context_scope_restore", { p_scope_id: scopeId }, scopeId),
+    async createField(scopeTypeId, spec) {
+      const res = await write("context_item_write", {
+        p_item_id: null,
+        p_scope_type_id: scopeTypeId,
+        p_spec: fieldSpecForDoor({ kind: "string", description: "", context_policy: "on_request", sensitivity: "internal", tags: [], ...spec })
+      });
+      if (!res.ok) return res;
+      return fieldById(scopeTypeId, String(res.data.id), "context_item_write");
+    },
+    async updateField(fieldId, scopeTypeId, spec) {
+      const res = await write("context_item_write", { p_item_id: fieldId, p_scope_type_id: null, p_spec: fieldSpecForDoor(spec) });
+      if (!res.ok) return res;
+      return fieldById(scopeTypeId, fieldId, "context_item_write");
+    },
+    archiveField: (fieldId) => archiveOrRestore("context_item_archive", { p_item_id: fieldId }, fieldId),
+    restoreField: (fieldId) => archiveOrRestore("context_item_restore", { p_item_id: fieldId }, fieldId),
+    async writeValue(cell) {
+      const res = await call(
+        "context_value_write",
+        { p_payload: { source_type: "ai_enriched", ...valuePayloadForDoor(cell) } },
+        "scopes.writeValue"
+      );
+      if (!res.ok) return res;
+      const envelope = res.data ?? {};
+      if (!envelope.ok) {
+        const code = VALUE_DOOR_CODES[envelope.error?.code ?? ""] ?? "internal";
+        return { ok: false, error: { code, message: envelope.error?.message ?? "The value was not saved." } };
+      }
+      return {
+        ok: true,
+        data: {
+          scope_id: cell.scope_id,
+          field_id: cell.field_id,
+          version: Number(envelope.data?.version ?? 1),
+          source_type: String(envelope.data?.source_type ?? cell.source_type ?? "ai_enriched")
+        }
+      };
+    }
+  };
+  return doors;
+}
+
 // src/choice.ts
 import { isUuidShape as isUuidShape2 } from "@ai-matrx/kit/uuid";
 var CHOICE_NUDGES = ["ask", "always_add", "never_add"];
@@ -2859,6 +3492,7 @@ function createRecordsClient(given) {
   const unavailableReason = (error) => `${error.message}${error.hint ? ` ${error.hint}` : ""}`;
   const client = {
     config,
+    scopes: createScopeDoors(callDoor),
     async recordWrite({ table_id, data }) {
       const result = await callDoor(
         DOORS.recordWrite,