@xnetjs/data 0.0.2 → 0.0.3

package/dist/chunk-QWFTRZQT.js

@@ -0,0 +1,142 @@
+// src/database/fractional-index.ts
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var BASE = ALPHABET.length;
+var START_KEY = "a0";
+var MIDPOINT_CHAR = ALPHABET[Math.floor(BASE / 2)];
+function generateSortKey(before, after) {
+  if (!before && !after) {
+    return START_KEY;
+  }
+  if (before && !after) {
+    return incrementKey(before);
+  }
+  if (!before && after) {
+    return prependKey(after);
+  }
+  return midpointKey(before, after);
+}
+function generateSortKeyWithJitter(before, after) {
+  const base = generateSortKey(before, after);
+  const jitter = ALPHABET[randomInt(BASE)] + ALPHABET[randomInt(BASE)];
+  return base + jitter;
+}
+function incrementKey(key) {
+  const chars = key.split("");
+  let i = chars.length - 1;
+  while (i >= 0) {
+    const idx = ALPHABET.indexOf(chars[i]);
+    if (idx < BASE - 1) {
+      chars[i] = ALPHABET[idx + 1];
+      return chars.join("");
+    }
+    chars[i] = ALPHABET[0];
+    i--;
+  }
+  return key + ALPHABET[0];
+}
+function prependKey(key) {
+  const chars = key.split("");
+  for (let i = 0; i < chars.length; i++) {
+    const idx = ALPHABET.indexOf(chars[i]);
+    if (idx > 0) {
+      chars[i] = ALPHABET[idx - 1];
+      return chars.slice(0, i + 1).join("") + ALPHABET[BASE - 1];
+    }
+  }
+  return ALPHABET[0] + key.slice(1) + MIDPOINT_CHAR;
+}
+function midpointKey(before, after) {
+  if (before >= after) {
+    throw new Error(`Invalid key order: "${before}" >= "${after}"`);
+  }
+  const maxLen = Math.max(before.length, after.length) + 1;
+  const paddedBefore = before.padEnd(maxLen, ALPHABET[0]);
+  const paddedAfter = after.padEnd(maxLen, ALPHABET[0]);
+  for (let i = 0; i < maxLen; i++) {
+    const beforeIdx = ALPHABET.indexOf(paddedBefore[i]);
+    const afterIdx = ALPHABET.indexOf(paddedAfter[i]);
+    if (beforeIdx === afterIdx) {
+      continue;
+    }
+    if (afterIdx - beforeIdx > 1) {
+      const midIdx = Math.floor((beforeIdx + afterIdx) / 2);
+      return paddedBefore.slice(0, i) + ALPHABET[midIdx];
+    }
+    for (let j = i + 1; j < maxLen; j++) {
+      const bIdx = ALPHABET.indexOf(paddedBefore[j]);
+      const aIdx = ALPHABET.indexOf(paddedAfter[j]);
+      if (aIdx > bIdx + 1) {
+        const midIdx = Math.floor((bIdx + aIdx) / 2);
+        return paddedBefore.slice(0, j) + ALPHABET[midIdx];
+      } else if (aIdx > bIdx) {
+        continue;
+      } else {
+        const midIdx = Math.floor((bIdx + BASE) / 2);
+        return paddedBefore.slice(0, j) + ALPHABET[midIdx];
+      }
+    }
+    return before + MIDPOINT_CHAR;
+  }
+  for (let i = before.length; i < after.length; i++) {
+    const afterIdx = ALPHABET.indexOf(after[i]);
+    if (afterIdx > 0) {
+      const midIdx = Math.floor(afterIdx / 2);
+      return before + ALPHABET[0].repeat(i - before.length) + ALPHABET[midIdx];
+    }
+  }
+  return before + MIDPOINT_CHAR;
+}
+function isValidSortKey(key) {
+  if (!key || key.length === 0) return false;
+  return key.split("").every((c) => ALPHABET.includes(c));
+}
+function compareSortKeys(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function rebalanceSortKeys(rowIds) {
+  const result = /* @__PURE__ */ new Map();
+  if (rowIds.length === 0) {
+    return result;
+  }
+  for (let i = 0; i < rowIds.length; i++) {
+    const key = indexToKey(i, rowIds.length);
+    result.set(rowIds[i], key);
+  }
+  return result;
+}
+function indexToKey(index, total) {
+  const charCount = total <= BASE * BASE ? 2 : 3;
+  const range = Math.pow(BASE, charCount);
+  const step = Math.floor(range / (total + 1));
+  const value = step * (index + 1);
+  return valueToKey(value, charCount);
+}
+function valueToKey(value, length) {
+  let result = "";
+  let remaining = value;
+  for (let i = 0; i < length; i++) {
+    const idx = remaining % BASE;
+    result = ALPHABET[idx] + result;
+    remaining = Math.floor(remaining / BASE);
+  }
+  return result;
+}
+function randomInt(max) {
+  return Math.floor(Math.random() * max);
+}
+var MAX_KEY_LENGTH = 10;
+function needsRebalancing(sortKeys) {
+  return sortKeys.some((key) => key.length > MAX_KEY_LENGTH);
+}
+
+export {
+  generateSortKey,
+  generateSortKeyWithJitter,
+  isValidSortKey,
+  compareSortKeys,
+  rebalanceSortKeys,
+  MAX_KEY_LENGTH,
+  needsRebalancing
+};

package/dist/chunk-RSSZXCLL.js

@@ -0,0 +1,51 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-6OPZJ7MG.js";
+import {
+  checkbox,
+  created,
+  createdBy,
+  date,
+  defineSchema,
+  file,
+  json,
+  relation,
+  text
+} from "./chunk-O64EK5FK.js";
+
+// src/schema/schemas/chat-message.ts
+var ChatMessageSchema = defineSchema({
+  name: "ChatMessage",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** The channel this message belongs to */
+    channel: relation({ target: "xnet://xnet.fyi/Channel@1.0.0", required: true }),
+    /** Message body in GitHub-flavored markdown */
+    content: text({ required: true, maxLength: 1e4 }),
+    /** Thread root message (flat threading, like Comment.inReplyTo) */
+    inReplyTo: relation({ target: "xnet://xnet.fyi/ChatMessage@1.0.0" }),
+    /** Optional file attachments */
+    attachments: file({ multiple: true }),
+    /** Structured mentions ({ dids, room? }) — populated by the composer */
+    mentions: json({}),
+    /** Whether the message has been edited */
+    edited: checkbox({ default: false }),
+    /** When the message was last edited */
+    editedAt: date({}),
+    /** Soft tombstone: content removed, message shell kept for thread shape */
+    redacted: checkbox({ default: false }),
+    /** Workspace-wide labels from inline #hashtag pills (exploration 0169) */
+    tags: relation({ target: "xnet://xnet.fyi/Tag@1.0.0", multiple: true }),
+    /** Node ids from the composer's [[ link picks (exploration 0170) */
+    links: relation({ multiple: true }),
+    createdAt: created(),
+    createdBy: createdBy()
+  },
+  document: void 0,
+  // Inherits access from its home Space (exploration 0181/0192).
+  authorization: spaceCascadeAuthorization("channel")
+});
+
+export {
+  ChatMessageSchema
+};

package/dist/chunk-S4B5OPZU.js

@@ -0,0 +1,415 @@
+// src/store/query.ts
+function sortRecord(record) {
+  if (!record) return void 0;
+  const entries = Object.entries(record).sort(([left], [right]) => left.localeCompare(right));
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries);
+}
+function normalizeSpatialPoint(point) {
+  return {
+    x: point.x,
+    y: point.y
+  };
+}
+function normalizeSpatialRect(rect) {
+  return {
+    x: rect.x,
+    y: rect.y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function normalizeSpatialFilter(spatial) {
+  if (!spatial) {
+    return void 0;
+  }
+  if (spatial.kind === "window") {
+    const overscan = spatial.overscan ?? 0;
+    return {
+      kind: "window",
+      rect: normalizeSpatialRect(spatial.rect),
+      fields: {
+        x: spatial.fields.x,
+        y: spatial.fields.y,
+        width: spatial.fields.width,
+        height: spatial.fields.height
+      },
+      ...overscan !== 0 ? { overscan } : {}
+    };
+  }
+  return {
+    kind: "radius",
+    center: normalizeSpatialPoint(spatial.center),
+    radius: spatial.radius,
+    fields: {
+      x: spatial.fields.x,
+      y: spatial.fields.y
+    }
+  };
+}
+function normalizeSearchFilter(search) {
+  if (typeof search === "string") {
+    const text2 = search.trim();
+    return text2.length > 0 ? { text: text2 } : void 0;
+  }
+  if (!search) {
+    return void 0;
+  }
+  const text = search.text.trim();
+  if (text.length === 0) {
+    return void 0;
+  }
+  const fields = search.fields ? [...new Set(search.fields)].filter((field) => field === "title" || field === "content").sort() : void 0;
+  return {
+    text,
+    ...fields && fields.length > 0 ? { fields } : {}
+  };
+}
+function normalizeMaterializedViewOptions(materializedView) {
+  if (typeof materializedView === "string") {
+    const viewId2 = materializedView.trim();
+    return viewId2.length > 0 ? { viewId: viewId2 } : void 0;
+  }
+  if (!materializedView) {
+    return void 0;
+  }
+  const viewId = materializedView.viewId.trim();
+  if (viewId.length === 0) {
+    return void 0;
+  }
+  const maxAgeMs = materializedView.maxAgeMs !== void 0 && Number.isFinite(materializedView.maxAgeMs) && materializedView.maxAgeMs >= 0 ? materializedView.maxAgeMs : void 0;
+  return {
+    viewId,
+    ...maxAgeMs !== void 0 ? { maxAgeMs } : {},
+    ...materializedView.forceRefresh ? { forceRefresh: true } : {}
+  };
+}
+var NODE_QUERY_CURSOR_PREFIX = "xnet-query-cursor:";
+function encodeBase64Url(value) {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function decodeBase64Url(value) {
+  const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
+  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function isSortDirection(value) {
+  return value === "asc" || value === "desc";
+}
+function isNodeQueryCursor(value) {
+  if (!value || typeof value !== "object") return false;
+  const cursor = value;
+  return cursor.version === 1 && typeof cursor.schemaId === "string" && typeof cursor.nodeId === "string" && Array.isArray(cursor.order) && cursor.order.every(
+    (entry) => entry && typeof entry === "object" && typeof entry.field === "string" && isSortDirection(entry.direction)
+  );
+}
+function getExplicitOrderEntries(descriptor) {
+  return Object.entries(descriptor.orderBy ?? {}).filter((entry) => isSortDirection(entry[1])).map(([field, direction]) => ({ field, direction }));
+}
+function getCursorOrderEntries(descriptor) {
+  const entries = getExplicitOrderEntries(descriptor);
+  return entries.length > 0 ? entries : [{ field: "updatedAt", direction: "desc" }];
+}
+function getSortOrderEntries(descriptor) {
+  const entries = getExplicitOrderEntries(descriptor);
+  if (entries.length === 0) {
+    return descriptor.after ? [...getCursorOrderEntries(descriptor), { field: "nodeId", direction: "asc" }] : [];
+  }
+  return [...entries, { field: "nodeId", direction: "asc" }];
+}
+function getOrderValue(node, field) {
+  if (field === "nodeId") return node.id;
+  if (field === "createdAt" || field === "updatedAt") return node[field];
+  return node.properties[field];
+}
+function compareOrderValues(leftValue, rightValue, direction) {
+  if (leftValue === rightValue) return 0;
+  if (leftValue == null) return direction === "asc" ? 1 : -1;
+  if (rightValue == null) return direction === "asc" ? -1 : 1;
+  const comparison = leftValue < rightValue ? -1 : 1;
+  return direction === "asc" ? comparison : -comparison;
+}
+function compareNodeToCursor(node, cursor) {
+  for (const entry of cursor.order) {
+    const comparison = compareOrderValues(
+      getOrderValue(node, entry.field),
+      entry.value,
+      entry.direction
+    );
+    if (comparison !== 0) return comparison;
+  }
+  return compareOrderValues(node.id, cursor.nodeId, "asc");
+}
+function filterAfterCursor(nodes, descriptor) {
+  if (!descriptor.after) return nodes;
+  const cursor = decodeNodeQueryCursor(descriptor.after);
+  if (!cursor || cursor.schemaId !== descriptor.schemaId) return nodes;
+  return nodes.filter((node) => compareNodeToCursor(node, cursor) > 0);
+}
+function encodeNodeQueryCursor(descriptor, node) {
+  const cursor = {
+    version: 1,
+    schemaId: descriptor.schemaId,
+    order: getCursorOrderEntries(descriptor).map((entry) => ({
+      field: entry.field,
+      direction: entry.direction,
+      value: getOrderValue(node, entry.field)
+    })),
+    nodeId: node.id
+  };
+  return `${NODE_QUERY_CURSOR_PREFIX}${encodeBase64Url(JSON.stringify(cursor))}`;
+}
+function decodeNodeQueryCursor(cursor) {
+  if (!cursor.startsWith(NODE_QUERY_CURSOR_PREFIX)) return null;
+  try {
+    const payload = JSON.parse(decodeBase64Url(cursor.slice(NODE_QUERY_CURSOR_PREFIX.length)));
+    return isNodeQueryCursor(payload) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+function getNodeQuerySearchTokens(search) {
+  return tokenizeSearchText(search.text);
+}
+function tokenizeSearchText(text) {
+  const tokens = text.toLocaleLowerCase().match(/[\p{L}\p{N}_]+/gu);
+  return [...new Set(tokens ?? [])];
+}
+function extractTipTapText(value) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const node = value;
+  const parts = [];
+  if (typeof node.text === "string") {
+    parts.push(node.text);
+  }
+  if (Array.isArray(node.content)) {
+    parts.push(...node.content.map(extractTipTapText));
+  }
+  return parts.join(" ").trim();
+}
+function getSearchableText(node, fields = ["title", "content"]) {
+  const parts = [];
+  if (fields.includes("title") && typeof node.properties.title === "string") {
+    parts.push(node.properties.title);
+  }
+  if (fields.includes("content")) {
+    const content = node.properties.content;
+    if (typeof content === "string") {
+      parts.push(content);
+    } else {
+      const richText = extractTipTapText(content);
+      if (richText.length > 0) {
+        parts.push(richText);
+      }
+    }
+    const description = node.properties.description;
+    if (typeof description === "string") {
+      parts.push(description);
+    }
+    const body = node.properties.body;
+    if (typeof body === "string") {
+      parts.push(body);
+    }
+  }
+  return parts.join(" ");
+}
+function getNumericProperty(properties, key) {
+  if (!key) {
+    return null;
+  }
+  const value = properties[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function matchesSpatialFilter(descriptor, node) {
+  const spatial = descriptor.spatial;
+  if (!spatial) {
+    return true;
+  }
+  const x = getNumericProperty(node.properties, spatial.fields.x);
+  const y = getNumericProperty(node.properties, spatial.fields.y);
+  if (x === null || y === null) {
+    return false;
+  }
+  if (spatial.kind === "radius") {
+    const dx = x - spatial.center.x;
+    const dy = y - spatial.center.y;
+    return dx * dx + dy * dy <= spatial.radius * spatial.radius;
+  }
+  const overscan = spatial.overscan ?? 0;
+  const left = spatial.rect.x - overscan;
+  const top = spatial.rect.y - overscan;
+  const right = spatial.rect.x + spatial.rect.width + overscan;
+  const bottom = spatial.rect.y + spatial.rect.height + overscan;
+  const width = getNumericProperty(node.properties, spatial.fields.width) ?? 0;
+  const height = getNumericProperty(node.properties, spatial.fields.height) ?? 0;
+  const nodeLeft = Math.min(x, x + width);
+  const nodeTop = Math.min(y, y + height);
+  const nodeRight = Math.max(x, x + width);
+  const nodeBottom = Math.max(y, y + height);
+  const isPointLike = width === 0 && height === 0;
+  if (isPointLike) {
+    return x >= left && x <= right && y >= top && y <= bottom;
+  }
+  return nodeRight >= left && nodeLeft <= right && nodeBottom >= top && nodeTop <= bottom;
+}
+function matchesSearchFilter(descriptor, node) {
+  const search = descriptor.search;
+  if (!search) {
+    return true;
+  }
+  const queryTokens = getNodeQuerySearchTokens(search);
+  if (queryTokens.length === 0) {
+    return false;
+  }
+  const searchableTokens = tokenizeSearchText(
+    getSearchableText(node, search.fields ?? ["title", "content"])
+  );
+  if (searchableTokens.length === 0) {
+    return false;
+  }
+  return queryTokens.every(
+    (queryToken) => searchableTokens.some((searchableToken) => searchableToken.startsWith(queryToken))
+  );
+}
+function createNodeQueryDescriptor(schemaId, options) {
+  return {
+    schemaId,
+    nodeId: options?.nodeId,
+    where: sortRecord(options?.where),
+    includeDeleted: options?.includeDeleted ?? false,
+    orderBy: sortRecord(options?.orderBy),
+    limit: options?.limit ?? options?.page?.first,
+    offset: options?.offset,
+    after: options?.page?.after,
+    count: options?.page?.count,
+    spatial: normalizeSpatialFilter(options?.spatial),
+    search: normalizeSearchFilter(options?.search),
+    materializedView: normalizeMaterializedViewOptions(options?.materializedView)
+  };
+}
+function nodeQueryDescriptorToOptions(descriptor) {
+  const options = {};
+  if (descriptor.nodeId) {
+    options.nodeId = descriptor.nodeId;
+  }
+  if (descriptor.where) {
+    options.where = descriptor.where;
+  }
+  if (descriptor.includeDeleted) {
+    options.includeDeleted = true;
+  }
+  if (descriptor.orderBy) {
+    options.orderBy = descriptor.orderBy;
+  }
+  if (descriptor.limit !== void 0) {
+    options.limit = descriptor.limit;
+  }
+  if (descriptor.offset !== void 0) {
+    options.offset = descriptor.offset;
+  }
+  if (descriptor.after || descriptor.count) {
+    options.page = {
+      first: descriptor.limit ?? 0,
+      ...descriptor.after ? { after: descriptor.after } : {},
+      ...descriptor.count ? { count: descriptor.count } : {}
+    };
+  }
+  if (descriptor.spatial) {
+    options.spatial = descriptor.spatial;
+  }
+  if (descriptor.search) {
+    options.search = descriptor.search;
+  }
+  if (descriptor.materializedView) {
+    options.materializedView = descriptor.materializedView;
+  }
+  return options;
+}
+function serializeNodeQueryDescriptor(descriptor) {
+  return JSON.stringify(descriptor);
+}
+function matchesNodeQueryDescriptor(descriptor, node) {
+  if (!node) return false;
+  if (node.schemaId !== descriptor.schemaId) return false;
+  if (descriptor.nodeId && node.id !== descriptor.nodeId) return false;
+  if (!descriptor.includeDeleted && node.deleted) return false;
+  if (descriptor.where) {
+    for (const [key, value] of Object.entries(descriptor.where)) {
+      if (node.properties[key] !== value) {
+        return false;
+      }
+    }
+  }
+  return matchesSpatialFilter(descriptor, node) && matchesSearchFilter(descriptor, node);
+}
+function filterNodeQueryResults(nodes, descriptor) {
+  return nodes.filter((node) => matchesNodeQueryDescriptor(descriptor, node));
+}
+function sortNodeQueryResults(nodes, descriptor) {
+  const entries = getSortOrderEntries(descriptor);
+  if (entries.length === 0) return nodes;
+  return [...nodes].sort((left, right) => {
+    for (const entry of entries) {
+      const comparison = compareOrderValues(
+        getOrderValue(left, entry.field),
+        getOrderValue(right, entry.field),
+        entry.direction
+      );
+      if (comparison !== 0) {
+        return comparison;
+      }
+    }
+    return 0;
+  });
+}
+function applyNodeQueryDescriptor(nodes, descriptor) {
+  const filtered = filterNodeQueryResults(nodes, descriptor);
+  const sorted = sortNodeQueryResults(filtered, descriptor);
+  const afterCursor = filterAfterCursor(sorted, descriptor);
+  const offset = descriptor.offset ?? 0;
+  if (descriptor.limit === void 0) {
+    return afterCursor.slice(offset);
+  }
+  return afterCursor.slice(offset, offset + descriptor.limit);
+}
+function nodeQueryDescriptorNeedsBoundedReload(descriptor) {
+  return descriptor.limit !== void 0 || (descriptor.offset ?? 0) > 0 || descriptor.after !== void 0;
+}
+function withoutNodeQueryPagination(descriptor) {
+  const next = { ...descriptor };
+  delete next.limit;
+  delete next.offset;
+  delete next.after;
+  delete next.count;
+  return next;
+}
+function withoutNodeQueryMaterializedView(descriptor) {
+  const next = { ...descriptor };
+  delete next.materializedView;
+  return next;
+}
+
+export {
+  encodeNodeQueryCursor,
+  decodeNodeQueryCursor,
+  getNodeQuerySearchTokens,
+  createNodeQueryDescriptor,
+  nodeQueryDescriptorToOptions,
+  serializeNodeQueryDescriptor,
+  matchesNodeQueryDescriptor,
+  filterNodeQueryResults,
+  sortNodeQueryResults,
+  applyNodeQueryDescriptor,
+  nodeQueryDescriptorNeedsBoundedReload,
+  withoutNodeQueryPagination,
+  withoutNodeQueryMaterializedView
+};

package/dist/{chunk-VYR5GPJP.js → chunk-SPFKSTPT.js}

@@ -1,20 +1,24 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-6OPZJ7MG.js";
 import {
   defineSchema,
   relation,
   text
-} from "./chunk-SZC345Z2.js";
+} from "./chunk-O64EK5FK.js";
 
 // src/schema/schemas/database-row.ts
 var DatabaseRowSchema = defineSchema({
   name: "DatabaseRow",
   namespace: "xnet://xnet.fyi/",
+  version: "2.0.0",
   properties: {
     /**
      * Reference to the parent database.
      * This is a typed relation that only accepts Database node IDs.
      */
     database: relation({
-      target: "xnet://xnet.fyi/Database@1.0.0",
+      target: "xnet://xnet.fyi/Database@2.0.0",
       required: true
     }),
     /**
@@ -31,7 +35,9 @@ var DatabaseRowSchema = defineSchema({
    * Only created when the row has rich text columns.
    * Each rich text column gets its own Y.XmlFragment in the doc.
    */
-  document: "yjs"
+  document: "yjs",
+  // Inherits access from its home Space (exploration 0181/0192).
+  authorization: spaceCascadeAuthorization("database")
 });
 
 export {

package/dist/chunk-U6CBYDVZ.js

@@ -0,0 +1,50 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-6OPZJ7MG.js";
+import {
+  defineSchema,
+  file,
+  relation,
+  select,
+  text
+} from "./chunk-O64EK5FK.js";
+
+// src/schema/schemas/page.ts
+var PageSchema = defineSchema({
+  name: "Page",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Page title */
+    title: text({ required: true, maxLength: 500 }),
+    /** Emoji or icon URL */
+    icon: text({}),
+    /** Cover image */
+    cover: file({ accept: ["image/*"] }),
+    /** Canonical home; empty = Unfiled (exploration 0169) */
+    folder: relation({ target: "xnet://xnet.fyi/Folder@1.0.0" }),
+    /** Order among folder siblings — fractional index */
+    sortKey: text({ maxLength: 500 }),
+    /** Workspace-wide labels, referenced by id (exploration 0169) */
+    tags: relation({ target: "xnet://xnet.fyi/Tag@1.0.0", multiple: true }),
+    /** Canonical SECURITY home; empty = personal/private (exploration 0179) */
+    space: relation({ target: "xnet://xnet.fyi/Space@1.0.0" }),
+    /** Per-node visibility; `inherit` defers to the Space (exploration 0179) */
+    visibility: select({
+      options: [
+        { id: "inherit", name: "Inherit", color: "gray" },
+        { id: "private", name: "Private", color: "gray" },
+        { id: "unlisted", name: "Unlisted", color: "yellow" },
+        { id: "public", name: "Public", color: "green" }
+      ],
+      default: "inherit"
+    })
+  },
+  document: "yjs",
+  // Collaborative Y.Doc for rich text
+  // Inherits access from its home Space (exploration 0181/0192).
+  authorization: spaceCascadeAuthorization()
+});
+
+export {
+  PageSchema
+};