@xnetjs/data 0.0.2 → 0.1.0

package/dist/chunk-K7DOZWWT.js

@@ -0,0 +1,1811 @@
+import {
+  ACCOUNT_RECORD_SCHEMA_IRI,
+  DEVICE_RECORD_SCHEMA_IRI,
+  REVOCATION_RECORD_SCHEMA_IRI,
+  accountRecordId,
+  deviceRecordId,
+  resolveActiveDevices,
+  revocationRecordId,
+  revokedSubjects
+} from "./chunk-KQUALW4O.js";
+import {
+  extKey
+} from "./chunk-PMUQACPY.js";
+import {
+  EXTENSION_FIELD_SCHEMA_IRI,
+  SCHEMA_EXTENSION_SCHEMA_IRI
+} from "./chunk-WEPK7SZF.js";
+import {
+  PresenceSummarySchema,
+  SchemaDefinitionSchema,
+  buildSystemNodeId,
+  validateSchemaDefinitionNode
+} from "./chunk-BY5O6LNC.js";
+import {
+  checkbox,
+  createNodeId,
+  created,
+  createdBy,
+  date,
+  dateRange,
+  email,
+  file,
+  getBaseSchemaIRI,
+  multiSelect,
+  normalizeSchemaIRI,
+  number,
+  parseSchemaIRI,
+  person,
+  phone,
+  relation,
+  select,
+  text,
+  updated,
+  url
+} from "./chunk-EBNMV2VO.js";
+
+// src/schema/schemas/task-identifiers.ts
+var TASK_SHORT_ID_PATTERN = /\b([A-Za-z]{1,5})-(\d{1,8})\b/;
+function formatTaskShortId(prefix, number2) {
+  return `${prefix.toUpperCase()}-${number2}`;
+}
+function parseTaskShortId(value) {
+  const match = TASK_SHORT_ID_PATTERN.exec(value.trim());
+  if (!match) return null;
+  const number2 = Number(match[2]);
+  if (!Number.isSafeInteger(number2) || number2 <= 0) return null;
+  return { prefix: match[1].toUpperCase(), number: number2 };
+}
+function taskBranchName(shortId, title, username) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/g, "");
+  const base = `${shortId.toLowerCase()}${slug ? `-${slug}` : ""}`;
+  return username ? `${username}/${base}` : base;
+}
+function* shortIdsFromBlock(block) {
+  for (let n = block.start; n <= block.end; n += 1) {
+    yield formatTaskShortId(block.prefix, n);
+  }
+}
+
+// src/schema/schemas/mentions.ts
+var MAX_MENTION_DIDS = 50;
+var DID_PATTERN = /^did:[a-z]+:[a-zA-Z0-9._:-]+$/;
+function normalizeMentions(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  const dids = Array.isArray(raw.dids) ? [
+    ...new Set(
+      raw.dids.filter((d) => typeof d === "string" && DID_PATTERN.test(d))
+    )
+  ].slice(0, MAX_MENTION_DIDS) : [];
+  const room = raw.room === true;
+  if (dids.length === 0 && !room) return void 0;
+  return room ? { dids, room: true } : { dids };
+}
+function mentionsInclude(mentions, did) {
+  return Boolean(mentions?.dids?.includes(did));
+}
+function isValidMentions(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value !== "object") return false;
+  const raw = value;
+  if (raw.room !== void 0 && typeof raw.room !== "boolean") return false;
+  if (!Array.isArray(raw.dids)) return false;
+  if (raw.dids.length > MAX_MENTION_DIDS) return false;
+  return raw.dids.every((d) => typeof d === "string" && DID_PATTERN.test(d));
+}
+
+// src/schema/schemas/account-ledger-ops.ts
+function createAccountRecord(args) {
+  return {
+    id: accountRecordId(args.accountId),
+    schemaId: ACCOUNT_RECORD_SCHEMA_IRI,
+    properties: {
+      accountId: args.accountId,
+      ...args.label ? { label: args.label } : {},
+      controllers: [...args.controllers],
+      epoch: args.epoch ?? 0
+    }
+  };
+}
+function admitDeviceRecord(args) {
+  return {
+    id: deviceRecordId(args.accountId, args.deviceDid),
+    schemaId: DEVICE_RECORD_SCHEMA_IRI,
+    properties: {
+      account: args.accountId,
+      deviceDid: args.deviceDid,
+      status: "active",
+      addedBy: args.addedBy,
+      addedAt: args.nowMs,
+      lastSeenAt: args.nowMs,
+      epoch: args.epoch,
+      ...args.label ? { label: args.label } : {},
+      ...args.rpId ? { rpId: args.rpId } : {},
+      ...args.credentialIdHash ? { credentialIdHash: args.credentialIdHash } : {},
+      ...args.capabilities !== void 0 ? { capabilities: args.capabilities } : {}
+    }
+  };
+}
+function nextEpoch(currentEpoch) {
+  return currentEpoch + 1;
+}
+function revokeSubjectRecord(args) {
+  const epoch = nextEpoch(args.currentEpoch);
+  return {
+    nextEpoch: epoch,
+    revocation: {
+      id: revocationRecordId(args.accountId, args.subject),
+      schemaId: REVOCATION_RECORD_SCHEMA_IRI,
+      properties: {
+        account: args.accountId,
+        subjectKind: args.subjectKind,
+        subject: args.subject,
+        signedBy: args.signedBy,
+        effectiveAt: args.nowMs,
+        epoch,
+        ...args.reason ? { reason: args.reason } : {}
+      }
+    }
+  };
+}
+function revokeDeviceRecord(args) {
+  return revokeSubjectRecord({ ...args, subject: args.deviceDid, subjectKind: "device" });
+}
+function accountState(input) {
+  return {
+    epoch: input.account?.epoch ?? 0,
+    activeDevices: resolveActiveDevices(input.devices, input.revocations),
+    revoked: revokedSubjects(input.revocations)
+  };
+}
+
+// src/schema/schemas/commentAnchors.ts
+function encodeAnchor(data) {
+  return JSON.stringify(data);
+}
+function decodeAnchor(json2) {
+  return JSON.parse(json2);
+}
+function isTextAnchor(data) {
+  return "startRelative" in data && "endRelative" in data;
+}
+function isCellAnchor(data) {
+  return "rowId" in data && "propertyKey" in data;
+}
+function isRowAnchor(data) {
+  return "rowId" in data && !("propertyKey" in data);
+}
+function isColumnAnchor(data) {
+  return "propertyKey" in data && !("rowId" in data);
+}
+function isCanvasPositionAnchor(data) {
+  return "x" in data && "y" in data && !("objectId" in data);
+}
+function isCanvasObjectAnchor(data) {
+  return "objectId" in data;
+}
+function isNodeAnchor(data) {
+  return Object.keys(data).length === 0;
+}
+
+// src/schema/schemas/commentReferences.ts
+var MENTION_REGEX = /@(did:key:z[a-zA-Z0-9]+|[a-zA-Z_][\w]*)/g;
+var COMMENT_REF_REGEX = /#([a-zA-Z0-9_-]{21})(?![a-zA-Z0-9_-])/g;
+var NODE_REF_REGEX = /\[\[([a-zA-Z0-9_-]{21})\]\]/g;
+function extractReferences(content) {
+  const refs = [];
+  MENTION_REGEX.lastIndex = 0;
+  COMMENT_REF_REGEX.lastIndex = 0;
+  NODE_REF_REGEX.lastIndex = 0;
+  let match;
+  while ((match = MENTION_REGEX.exec(content)) !== null) {
+    const value = match[1];
+    refs.push({
+      type: "user",
+      raw: match[0],
+      did: value.startsWith("did:") ? value : void 0,
+      displayName: value.startsWith("did:") ? void 0 : value,
+      index: match.index
+    });
+  }
+  while ((match = COMMENT_REF_REGEX.exec(content)) !== null) {
+    refs.push({
+      type: "comment",
+      raw: match[0],
+      commentId: match[1],
+      index: match.index
+    });
+  }
+  while ((match = NODE_REF_REGEX.exec(content)) !== null) {
+    refs.push({
+      type: "node",
+      raw: match[0],
+      nodeId: match[1],
+      index: match.index
+    });
+  }
+  return refs.sort((a, b) => a.index - b.index);
+}
+function extractMentions(content) {
+  return extractReferences(content).filter((r) => r.type === "user");
+}
+function getMentionedUsers(content) {
+  return extractMentions(content).map((m) => m.did ?? m.displayName).filter((id) => id !== void 0);
+}
+
+// src/schema/schemas/commentOrphans.ts
+function checkOrphanStatus(anchorType, anchorData, resolvers) {
+  try {
+    switch (anchorType) {
+      case "text": {
+        if (!resolvers.resolveTextAnchor) {
+          return { orphaned: false };
+        }
+        const anchor = decodeAnchor(anchorData);
+        const resolved = resolvers.resolveTextAnchor(anchor);
+        if (resolved === null) {
+          return {
+            orphaned: true,
+            reason: "text-deleted",
+            context: anchor.quotedText
+          };
+        }
+        return { orphaned: false };
+      }
+      case "cell": {
+        const anchor = decodeAnchor(anchorData);
+        if (resolvers.rowExists && !resolvers.rowExists(anchor.rowId)) {
+          return {
+            orphaned: true,
+            reason: "row-deleted",
+            context: `Row ${anchor.rowId.slice(0, 8)}`
+          };
+        }
+        if (resolvers.columnExists && !resolvers.columnExists(anchor.propertyKey)) {
+          return {
+            orphaned: true,
+            reason: "column-deleted",
+            context: `Column "${anchor.propertyKey}"`
+          };
+        }
+        return { orphaned: false };
+      }
+      case "row": {
+        const anchor = decodeAnchor(anchorData);
+        if (resolvers.rowExists && !resolvers.rowExists(anchor.rowId)) {
+          return {
+            orphaned: true,
+            reason: "row-deleted",
+            context: `Row ${anchor.rowId.slice(0, 8)}`
+          };
+        }
+        return { orphaned: false };
+      }
+      case "column": {
+        const anchor = decodeAnchor(anchorData);
+        if (resolvers.columnExists && !resolvers.columnExists(anchor.propertyKey)) {
+          return {
+            orphaned: true,
+            reason: "column-deleted",
+            context: `Column "${anchor.propertyKey}"`
+          };
+        }
+        return { orphaned: false };
+      }
+      case "canvas-object": {
+        const anchor = decodeAnchor(anchorData);
+        if (resolvers.objectExists && !resolvers.objectExists(anchor.objectId)) {
+          return {
+            orphaned: true,
+            reason: "object-deleted",
+            context: `Object ${anchor.objectId.slice(0, 8)}`
+          };
+        }
+        return { orphaned: false };
+      }
+      case "canvas-position":
+        return { orphaned: false };
+      case "node":
+        return { orphaned: false };
+      default:
+        return { orphaned: false };
+    }
+  } catch {
+    return {
+      orphaned: true,
+      reason: "invalid-anchor",
+      context: "Invalid anchor data"
+    };
+  }
+}
+function filterOrphanedComments(comments, resolvers) {
+  const active = [];
+  const orphaned = [];
+  for (const comment of comments) {
+    const status = checkOrphanStatus(
+      comment.properties.anchorType,
+      comment.properties.anchorData,
+      resolvers
+    );
+    if (status.orphaned) {
+      orphaned.push({ comment, status });
+    } else {
+      active.push(comment);
+    }
+  }
+  return { active, orphaned };
+}
+
+// src/schema/schemas/index.ts
+var builtInSchemas = {
+  // Versioned IRIs (canonical)
+  "xnet://xnet.fyi/Page@1.0.0": () => import("./page-2V27JGKJ.js").then((m) => m.PageSchema),
+  "xnet://xnet.fyi/Folder@1.0.0": () => import("./folder-6KM3KYD5.js").then((m) => m.FolderSchema),
+  "xnet://xnet.fyi/Tag@1.0.0": () => import("./tag-SKCHM3U5.js").then((m) => m.TagSchema),
+  "xnet://xnet.fyi/Database@2.0.0": () => import("./database-GIXSPZJW.js").then((m) => m.DatabaseSchema),
+  "xnet://xnet.fyi/DatabaseRow@2.0.0": () => import("./database-row-6Q6TRVE4.js").then((m) => m.DatabaseRowSchema),
+  "xnet://xnet.fyi/DatabaseField@1.0.0": () => import("./database-field-3EPAMZUR.js").then((m) => m.DatabaseFieldSchema),
+  "xnet://xnet.fyi/DatabaseSelectOption@1.0.0": () => import("./database-select-option-BBBJFLLH.js").then((m) => m.DatabaseSelectOptionSchema),
+  "xnet://xnet.fyi/DatabaseView@1.0.0": () => import("./database-view-5PLSOBI2.js").then((m) => m.DatabaseViewSchema),
+  "xnet://xnet.fyi/SchemaExtension@1.0.0": () => import("./schema-extension-LNRF2YRD.js").then((m) => m.SchemaExtensionSchema),
+  "xnet://xnet.fyi/ExtensionField@1.0.0": () => import("./schema-extension-LNRF2YRD.js").then((m) => m.ExtensionFieldSchema),
+  "xnet://xnet.fyi/Task@1.0.0": () => import("./task-7AOBP7WC.js").then((m) => m.TaskSchema),
+  "xnet://xnet.fyi/TaskView@1.0.0": () => import("./task-view-NUGKELJP.js").then((m) => m.TaskViewSchema),
+  "xnet://xnet.fyi/Project@1.0.0": () => import("./project-CQL5LN26.js").then((m) => m.ProjectSchema),
+  "xnet://xnet.fyi/Metric@1.0.0": () => import("./metric-65SVOX5C.js").then((m) => m.MetricSchema),
+  "xnet://xnet.fyi/Observation@1.0.0": () => import("./observation-2Y3QKUXM.js").then((m) => m.ObservationSchema),
+  "xnet://xnet.fyi/Experiment@1.0.0": () => import("./experiment-DOVOZ34Y.js").then((m) => m.ExperimentSchema),
+  "xnet://xnet.fyi/Milestone@1.0.0": () => import("./milestone-XEO6ZGDG.js").then((m) => m.MilestoneSchema),
+  // CRM schema pack (exploration 0188)
+  "xnet://xnet.fyi/Organization@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.OrganizationSchema),
+  "xnet://xnet.fyi/Contact@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.ContactSchema),
+  "xnet://xnet.fyi/Relationship@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.RelationshipSchema),
+  "xnet://xnet.fyi/Pipeline@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.PipelineSchema),
+  "xnet://xnet.fyi/Stage@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.StageSchema),
+  "xnet://xnet.fyi/Deal@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.DealSchema),
+  "xnet://xnet.fyi/DealContactRole@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.DealContactRoleSchema),
+  "xnet://xnet.fyi/Activity@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.ActivitySchema),
+  "xnet://xnet.fyi/Product@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.ProductSchema),
+  "xnet://xnet.fyi/LineItem@1.0.0": () => import("./crm-L5RYAAF3.js").then((m) => m.LineItemSchema),
+  // Double-entry accounting + personal finance (exploration 0187)
+  "xnet://xnet.fyi/Account@1.0.0": () => import("./account-MWNCH4GJ.js").then((m) => m.AccountSchema),
+  "xnet://xnet.fyi/Transaction@1.0.0": () => import("./transaction-ZDSEGDIR.js").then((m) => m.TransactionSchema),
+  "xnet://xnet.fyi/Posting@1.0.0": () => import("./posting-GBOSZCMZ.js").then((m) => m.PostingSchema),
+  "xnet://xnet.fyi/Budget@1.0.0": () => import("./budget-NN7P35XP.js").then((m) => m.BudgetSchema),
+  "xnet://xnet.fyi/ImportBatch@1.0.0": () => import("./import-batch-IXBJLQPJ.js").then((m) => m.ImportBatchSchema),
+  "xnet://xnet.fyi/Space@1.0.0": () => import("./space-IJU24PBH.js").then((m) => m.SpaceSchema),
+  "xnet://xnet.fyi/SpaceMembership@1.0.0": () => import("./space-membership-DEUMM7NV.js").then((m) => m.SpaceMembershipSchema),
+  "xnet://xnet.fyi/ExternalReference@1.0.0": () => import("./external-reference-7BSFF6SA.js").then((m) => m.ExternalReferenceSchema),
+  "xnet://xnet.fyi/MediaAsset@1.0.0": () => import("./media-asset-QTCGLIZA.js").then((m) => m.MediaAssetSchema),
+  "xnet://xnet.fyi/Transcription@1.0.0": () => import("./transcription-PSCLDAGX.js").then((m) => m.TranscriptionSchema),
+  "xnet://xnet.fyi/Canvas@1.0.0": () => import("./canvas-6WYBNH53.js").then((m) => m.CanvasSchema),
+  "xnet://xnet.fyi/Map@1.0.0": () => import("./map-RG5Y3CPC.js").then((m) => m.MapSchema),
+  "xnet://xnet.fyi/Comment@1.0.0": () => import("./comment-QSWYAQVS.js").then((m) => m.CommentSchema),
+  "xnet://xnet.fyi/Reaction@1.0.0": () => import("./reaction-T2DTJBBV.js").then((m) => m.ReactionSchema),
+  "xnet://xnet.fyi/Profile@1.0.0": () => import("./profile-BLLDWIDK.js").then((m) => m.ProfileSchema),
+  "xnet://xnet.fyi/Channel@1.0.0": () => import("./channel-AT3LQF4A.js").then((m) => m.ChannelSchema),
+  "xnet://xnet.fyi/ChatMessage@1.0.0": () => import("./chat-message-DSVO72B3.js").then((m) => m.ChatMessageSchema),
+  // Integration schema pack (exploration 0213)
+  "xnet://xnet.fyi/Feed@1.0.0": () => import("./feed-2IXHHP6O.js").then((m) => m.FeedSchema),
+  "xnet://xnet.fyi/FeedItem@1.0.0": () => import("./feed-item-DPE6LN7I.js").then((m) => m.FeedItemSchema),
+  "xnet://xnet.fyi/ExternalItem@1.0.0": () => import("./external-item-P2E5X7BZ.js").then((m) => m.ExternalItemSchema),
+  "xnet://xnet.fyi/InboxState@1.0.0": () => import("./inbox-state-E5NSVOGP.js").then((m) => m.InboxStateSchema),
+  "xnet://xnet.fyi/Grant@1.0.0": () => import("./grant-WTQSNT5A.js").then((m) => m.GrantSchema),
+  "xnet://xnet.fyi/AccountRecord@1.0.0": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.AccountRecordSchema),
+  "xnet://xnet.fyi/DeviceRecord@1.0.0": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.DeviceRecordSchema),
+  "xnet://xnet.fyi/RecoveryRecord@1.0.0": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.RecoveryRecordSchema),
+  "xnet://xnet.fyi/RevocationRecord@1.0.0": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.RevocationRecordSchema),
+  "xnet://xnet.fyi/SavedView@1.0.0": () => import("./saved-view-4R2DBCL3.js").then((m) => m.SavedViewSchema),
+  "xnet://xnet.fyi/Dashboard@1.0.0": () => import("./dashboard-JMKTTRA7.js").then((m) => m.DashboardSchema),
+  "xnet://xnet.fyi/UserWidget@1.0.0": () => import("./user-widget-RLY2N46A.js").then((m) => m.UserWidgetSchema),
+  "xnet://xnet.fyi/SchemaDefinition@1.0.0": () => import("./system-ILHCZOVO.js").then((m) => m.SchemaDefinitionSchema),
+  "xnet://xnet.fyi/SchemaCompatibility@1.0.0": () => import("./system-ILHCZOVO.js").then((m) => m.SchemaCompatibilitySchema),
+  "xnet://xnet.fyi/SyncPolicy@1.0.0": () => import("./system-ILHCZOVO.js").then((m) => m.SyncPolicySchema),
+  "xnet://xnet.fyi/PresenceSummary@1.0.0": () => import("./system-ILHCZOVO.js").then((m) => m.PresenceSummarySchema),
+  "xnet://xnet.fyi/AbuseReport@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.AbuseReportSchema),
+  "xnet://xnet.fyi/ModerationLabel@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.ModerationLabelSchema),
+  "xnet://xnet.fyi/PolicyList@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.PolicyListSchema),
+  "xnet://xnet.fyi/PolicySubscription@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.PolicySubscriptionSchema),
+  "xnet://xnet.fyi/PublicInteractionPolicy@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.PublicInteractionPolicySchema),
+  "xnet://xnet.fyi/MessageRequest@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.MessageRequestSchema),
+  "xnet://xnet.fyi/CommunityNote@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.CommunityNoteSchema),
+  "xnet://xnet.fyi/NoteRating@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.NoteRatingSchema),
+  "xnet://xnet.fyi/QualitySignal@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.QualitySignalSchema),
+  "xnet://xnet.fyi/ContentProvenance@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.ContentProvenanceSchema),
+  "xnet://xnet.fyi/Appeal@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.AppealSchema),
+  "xnet://xnet.fyi/ReviewTask@1.0.0": () => import("./moderation-FFHETMRB.js").then((m) => m.ReviewTaskSchema),
+  // Game-interop schema pack (exploration 0200)
+  "xnet://xnet.fyi/PlayerIdentity@1.0.0": () => import("./game-5AK5XWBR.js").then((m) => m.PlayerIdentitySchema),
+  "xnet://xnet.fyi/Inventory@1.0.0": () => import("./game-5AK5XWBR.js").then((m) => m.InventorySchema),
+  "xnet://xnet.fyi/GameItem@1.0.0": () => import("./game-5AK5XWBR.js").then((m) => m.GameItemSchema),
+  "xnet://xnet.fyi/Achievement@1.0.0": () => import("./game-5AK5XWBR.js").then((m) => m.AchievementSchema),
+  "xnet://xnet.fyi/MatchSession@1.0.0": () => import("./game-5AK5XWBR.js").then((m) => m.MatchSessionSchema),
+  "xnet://xnet.fyi/GameEconomyEntry@1.0.0": () => import("./game-5AK5XWBR.js").then((m) => m.GameEconomyEntrySchema),
+  "xnet://xnet.fyi/GameAsset@1.0.0": () => import("./game-5AK5XWBR.js").then((m) => m.GameAssetSchema),
+  // Memory schema pack (exploration 0211)
+  "xnet://xnet.fyi/MemoryItem@1.0.0": () => import("./memory-PNRTMBZO.js").then((m) => m.MemoryItemSchema),
+  // Legacy unversioned IRIs (aliases for the current version)
+  "xnet://xnet.fyi/Page": () => import("./page-2V27JGKJ.js").then((m) => m.PageSchema),
+  "xnet://xnet.fyi/Folder": () => import("./folder-6KM3KYD5.js").then((m) => m.FolderSchema),
+  "xnet://xnet.fyi/Tag": () => import("./tag-SKCHM3U5.js").then((m) => m.TagSchema),
+  "xnet://xnet.fyi/Database": () => import("./database-GIXSPZJW.js").then((m) => m.DatabaseSchema),
+  "xnet://xnet.fyi/DatabaseRow": () => import("./database-row-6Q6TRVE4.js").then((m) => m.DatabaseRowSchema),
+  "xnet://xnet.fyi/DatabaseField": () => import("./database-field-3EPAMZUR.js").then((m) => m.DatabaseFieldSchema),
+  "xnet://xnet.fyi/DatabaseSelectOption": () => import("./database-select-option-BBBJFLLH.js").then((m) => m.DatabaseSelectOptionSchema),
+  "xnet://xnet.fyi/DatabaseView": () => import("./database-view-5PLSOBI2.js").then((m) => m.DatabaseViewSchema),
+  "xnet://xnet.fyi/SchemaExtension": () => import("./schema-extension-LNRF2YRD.js").then((m) => m.SchemaExtensionSchema),
+  "xnet://xnet.fyi/ExtensionField": () => import("./schema-extension-LNRF2YRD.js").then((m) => m.ExtensionFieldSchema),
+  "xnet://xnet.fyi/Task": () => import("./task-7AOBP7WC.js").then((m) => m.TaskSchema),
+  "xnet://xnet.fyi/TaskView": () => import("./task-view-NUGKELJP.js").then((m) => m.TaskViewSchema),
+  "xnet://xnet.fyi/Project": () => import("./project-CQL5LN26.js").then((m) => m.ProjectSchema),
+  "xnet://xnet.fyi/Metric": () => import("./metric-65SVOX5C.js").then((m) => m.MetricSchema),
+  "xnet://xnet.fyi/Observation": () => import("./observation-2Y3QKUXM.js").then((m) => m.ObservationSchema),
+  "xnet://xnet.fyi/Experiment": () => import("./experiment-DOVOZ34Y.js").then((m) => m.ExperimentSchema),
+  "xnet://xnet.fyi/Milestone": () => import("./milestone-XEO6ZGDG.js").then((m) => m.MilestoneSchema),
+  "xnet://xnet.fyi/Organization": () => import("./crm-L5RYAAF3.js").then((m) => m.OrganizationSchema),
+  "xnet://xnet.fyi/Contact": () => import("./crm-L5RYAAF3.js").then((m) => m.ContactSchema),
+  "xnet://xnet.fyi/Relationship": () => import("./crm-L5RYAAF3.js").then((m) => m.RelationshipSchema),
+  "xnet://xnet.fyi/Pipeline": () => import("./crm-L5RYAAF3.js").then((m) => m.PipelineSchema),
+  "xnet://xnet.fyi/Stage": () => import("./crm-L5RYAAF3.js").then((m) => m.StageSchema),
+  "xnet://xnet.fyi/Deal": () => import("./crm-L5RYAAF3.js").then((m) => m.DealSchema),
+  "xnet://xnet.fyi/DealContactRole": () => import("./crm-L5RYAAF3.js").then((m) => m.DealContactRoleSchema),
+  "xnet://xnet.fyi/Activity": () => import("./crm-L5RYAAF3.js").then((m) => m.ActivitySchema),
+  "xnet://xnet.fyi/Product": () => import("./crm-L5RYAAF3.js").then((m) => m.ProductSchema),
+  "xnet://xnet.fyi/LineItem": () => import("./crm-L5RYAAF3.js").then((m) => m.LineItemSchema),
+  "xnet://xnet.fyi/Account": () => import("./account-MWNCH4GJ.js").then((m) => m.AccountSchema),
+  "xnet://xnet.fyi/Transaction": () => import("./transaction-ZDSEGDIR.js").then((m) => m.TransactionSchema),
+  "xnet://xnet.fyi/Posting": () => import("./posting-GBOSZCMZ.js").then((m) => m.PostingSchema),
+  "xnet://xnet.fyi/Budget": () => import("./budget-NN7P35XP.js").then((m) => m.BudgetSchema),
+  "xnet://xnet.fyi/ImportBatch": () => import("./import-batch-IXBJLQPJ.js").then((m) => m.ImportBatchSchema),
+  "xnet://xnet.fyi/Space": () => import("./space-IJU24PBH.js").then((m) => m.SpaceSchema),
+  "xnet://xnet.fyi/SpaceMembership": () => import("./space-membership-DEUMM7NV.js").then((m) => m.SpaceMembershipSchema),
+  "xnet://xnet.fyi/ExternalReference": () => import("./external-reference-7BSFF6SA.js").then((m) => m.ExternalReferenceSchema),
+  "xnet://xnet.fyi/MediaAsset": () => import("./media-asset-QTCGLIZA.js").then((m) => m.MediaAssetSchema),
+  "xnet://xnet.fyi/Transcription": () => import("./transcription-PSCLDAGX.js").then((m) => m.TranscriptionSchema),
+  "xnet://xnet.fyi/Canvas": () => import("./canvas-6WYBNH53.js").then((m) => m.CanvasSchema),
+  "xnet://xnet.fyi/Map": () => import("./map-RG5Y3CPC.js").then((m) => m.MapSchema),
+  "xnet://xnet.fyi/Comment": () => import("./comment-QSWYAQVS.js").then((m) => m.CommentSchema),
+  "xnet://xnet.fyi/Reaction": () => import("./reaction-T2DTJBBV.js").then((m) => m.ReactionSchema),
+  "xnet://xnet.fyi/Profile": () => import("./profile-BLLDWIDK.js").then((m) => m.ProfileSchema),
+  "xnet://xnet.fyi/Channel": () => import("./channel-AT3LQF4A.js").then((m) => m.ChannelSchema),
+  "xnet://xnet.fyi/ChatMessage": () => import("./chat-message-DSVO72B3.js").then((m) => m.ChatMessageSchema),
+  "xnet://xnet.fyi/Feed": () => import("./feed-2IXHHP6O.js").then((m) => m.FeedSchema),
+  "xnet://xnet.fyi/FeedItem": () => import("./feed-item-DPE6LN7I.js").then((m) => m.FeedItemSchema),
+  "xnet://xnet.fyi/ExternalItem": () => import("./external-item-P2E5X7BZ.js").then((m) => m.ExternalItemSchema),
+  "xnet://xnet.fyi/InboxState": () => import("./inbox-state-E5NSVOGP.js").then((m) => m.InboxStateSchema),
+  "xnet://xnet.fyi/Grant": () => import("./grant-WTQSNT5A.js").then((m) => m.GrantSchema),
+  "xnet://xnet.fyi/AccountRecord": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.AccountRecordSchema),
+  "xnet://xnet.fyi/DeviceRecord": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.DeviceRecordSchema),
+  "xnet://xnet.fyi/RecoveryRecord": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.RecoveryRecordSchema),
+  "xnet://xnet.fyi/RevocationRecord": () => import("./account-ledger-R2GAFJL6.js").then((m) => m.RevocationRecordSchema),
+  "xnet://xnet.fyi/SavedView": () => import("./saved-view-4R2DBCL3.js").then((m) => m.SavedViewSchema),
+  "xnet://xnet.fyi/Dashboard": () => import("./dashboard-JMKTTRA7.js").then((m) => m.DashboardSchema),
+  "xnet://xnet.fyi/UserWidget": () => import("./user-widget-RLY2N46A.js").then((m) => m.UserWidgetSchema),
+  "xnet://xnet.fyi/SchemaDefinition": () => import("./system-ILHCZOVO.js").then((m) => m.SchemaDefinitionSchema),
+  "xnet://xnet.fyi/SchemaCompatibility": () => import("./system-ILHCZOVO.js").then((m) => m.SchemaCompatibilitySchema),
+  "xnet://xnet.fyi/SyncPolicy": () => import("./system-ILHCZOVO.js").then((m) => m.SyncPolicySchema),
+  "xnet://xnet.fyi/PresenceSummary": () => import("./system-ILHCZOVO.js").then((m) => m.PresenceSummarySchema),
+  "xnet://xnet.fyi/AbuseReport": () => import("./moderation-FFHETMRB.js").then((m) => m.AbuseReportSchema),
+  "xnet://xnet.fyi/ModerationLabel": () => import("./moderation-FFHETMRB.js").then((m) => m.ModerationLabelSchema),
+  "xnet://xnet.fyi/PolicyList": () => import("./moderation-FFHETMRB.js").then((m) => m.PolicyListSchema),
+  "xnet://xnet.fyi/PolicySubscription": () => import("./moderation-FFHETMRB.js").then((m) => m.PolicySubscriptionSchema),
+  "xnet://xnet.fyi/PublicInteractionPolicy": () => import("./moderation-FFHETMRB.js").then((m) => m.PublicInteractionPolicySchema),
+  "xnet://xnet.fyi/MessageRequest": () => import("./moderation-FFHETMRB.js").then((m) => m.MessageRequestSchema),
+  "xnet://xnet.fyi/CommunityNote": () => import("./moderation-FFHETMRB.js").then((m) => m.CommunityNoteSchema),
+  "xnet://xnet.fyi/NoteRating": () => import("./moderation-FFHETMRB.js").then((m) => m.NoteRatingSchema),
+  "xnet://xnet.fyi/QualitySignal": () => import("./moderation-FFHETMRB.js").then((m) => m.QualitySignalSchema),
+  "xnet://xnet.fyi/ContentProvenance": () => import("./moderation-FFHETMRB.js").then((m) => m.ContentProvenanceSchema),
+  "xnet://xnet.fyi/Appeal": () => import("./moderation-FFHETMRB.js").then((m) => m.AppealSchema),
+  "xnet://xnet.fyi/ReviewTask": () => import("./moderation-FFHETMRB.js").then((m) => m.ReviewTaskSchema),
+  // Game-interop schema pack (exploration 0200)
+  "xnet://xnet.fyi/PlayerIdentity": () => import("./game-5AK5XWBR.js").then((m) => m.PlayerIdentitySchema),
+  "xnet://xnet.fyi/Inventory": () => import("./game-5AK5XWBR.js").then((m) => m.InventorySchema),
+  "xnet://xnet.fyi/GameItem": () => import("./game-5AK5XWBR.js").then((m) => m.GameItemSchema),
+  "xnet://xnet.fyi/Achievement": () => import("./game-5AK5XWBR.js").then((m) => m.AchievementSchema),
+  "xnet://xnet.fyi/MatchSession": () => import("./game-5AK5XWBR.js").then((m) => m.MatchSessionSchema),
+  "xnet://xnet.fyi/GameEconomyEntry": () => import("./game-5AK5XWBR.js").then((m) => m.GameEconomyEntrySchema),
+  "xnet://xnet.fyi/GameAsset": () => import("./game-5AK5XWBR.js").then((m) => m.GameAssetSchema),
+  // Memory schema pack (exploration 0211)
+  "xnet://xnet.fyi/MemoryItem": () => import("./memory-PNRTMBZO.js").then((m) => m.MemoryItemSchema)
+};
+
+// src/schema/effective-schema.ts
+function buildEffectiveSchema(core, extensions) {
+  if (extensions.length === 0) return core;
+  const lockedCore = core.properties.map((property) => ({
+    ...property,
+    readonly: true
+  }));
+  const extensionProperties = extensions.map((field) => {
+    const key = extKey(field.authority, field.name);
+    return {
+      "@id": `${core["@id"]}#${key}`,
+      name: key,
+      type: field.type,
+      required: false,
+      readonly: false,
+      ...field.config ? { config: field.config } : {}
+    };
+  });
+  return { ...core, properties: [...lockedCore, ...extensionProperties] };
+}
+function lockedPropertyKeys(schema) {
+  return schema.properties.filter((property) => property.readonly).map((property) => property.name);
+}
+function canModifyColumn(schema, propertyName) {
+  const property = schema.properties.find((entry) => entry.name === propertyName);
+  if (!property) return false;
+  return property.readonly !== true;
+}
+function findLockedColumns(schema, propertyNames) {
+  const locked = new Set(lockedPropertyKeys(schema));
+  const violations = [];
+  for (const name of propertyNames) {
+    if (locked.has(name)) violations.push(name);
+  }
+  return violations;
+}
+
+// src/schema/extension-resolver.ts
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function selectExtensionFields(targetSchema, extensions, fields) {
+  const base = getBaseSchemaIRI(targetSchema);
+  const authorityByExtensionId = /* @__PURE__ */ new Map();
+  for (const ext of extensions) {
+    if (ext.deleted) continue;
+    const target = readString(ext.targetSchema);
+    const authority = readString(ext.authority);
+    if (!target || !authority) continue;
+    if (target === targetSchema || getBaseSchemaIRI(target) === base) {
+      authorityByExtensionId.set(ext.id, authority);
+    }
+  }
+  if (authorityByExtensionId.size === 0) return [];
+  const collected = [];
+  for (const field of fields) {
+    if (field.deleted) continue;
+    const extensionId = readString(field.extension);
+    if (!extensionId) continue;
+    const authority = authorityByExtensionId.get(extensionId);
+    if (!authority) continue;
+    const name = readString(field.name);
+    const type = readString(field.type);
+    if (!name || !type) continue;
+    const config = field.config && typeof field.config === "object" ? field.config : void 0;
+    collected.push({
+      sortKey: readString(field.sortKey) ?? "",
+      field: { authority, name, type, ...config ? { config } : {} }
+    });
+  }
+  collected.sort((a, b) => a.sortKey < b.sortKey ? -1 : a.sortKey > b.sortKey ? 1 : 0);
+  return collected.map((entry) => entry.field);
+}
+async function loadExtensionFields(store, targetSchema) {
+  const [extensionNodes, fieldNodes] = await Promise.all([
+    store.list({ schemaId: SCHEMA_EXTENSION_SCHEMA_IRI }),
+    store.list({ schemaId: EXTENSION_FIELD_SCHEMA_IRI })
+  ]);
+  return selectExtensionFields(
+    targetSchema,
+    extensionNodes.map((node) => ({ id: node.id, deleted: node.deleted, ...node.properties })),
+    fieldNodes.map((node) => ({ deleted: node.deleted, ...node.properties }))
+  );
+}
+async function resolveEffectiveSchema(options) {
+  const { store, registry, schemaId } = options;
+  const defined = await registry.get(schemaId);
+  if (!defined) return null;
+  const extensions = await loadExtensionFields(store, schemaId);
+  return buildEffectiveSchema(defined.schema, extensions);
+}
+
+// src/schema/sidecar.ts
+var SIDECAR_PREFIX = "sidecar:";
+function sidecarId(authority, targetId) {
+  return `${SIDECAR_PREFIX}${authority}:${targetId}`;
+}
+var RESERVED_SIDECAR_KEYS = /* @__PURE__ */ new Set(["target", "space"]);
+function sidecarOverlayKeys(overlay) {
+  const excluded = new Set(RESERVED_SIDECAR_KEYS);
+  for (const key of overlay.exclude ?? []) excluded.add(key);
+  const out = {};
+  for (const [field, value] of Object.entries(overlay.properties)) {
+    if (excluded.has(field)) continue;
+    try {
+      out[extKey(overlay.authority, field)] = value;
+    } catch {
+    }
+  }
+  return out;
+}
+function mergeSidecarsIntoRow(baseProps, sidecars) {
+  const merged = {};
+  for (const sidecar of sidecars) {
+    Object.assign(merged, sidecarOverlayKeys(sidecar));
+  }
+  return { ...merged, ...baseProps };
+}
+
+// src/schema/registry.ts
+var SchemaRegistry = class {
+  schemas = /* @__PURE__ */ new Map();
+  loadingPromises = /* @__PURE__ */ new Map();
+  remoteResolver = null;
+  /**
+   * Register a custom schema.
+   *
+   * @param schema - The defined schema to register
+   * @throws If a schema with this IRI is already registered
+   */
+  register(schema) {
+    const iri = schema.schema["@id"];
+    if (this.schemas.has(iri)) {
+      throw new Error(`Schema already registered: ${iri}`);
+    }
+    this.schemas.set(iri, {
+      schema,
+      builtIn: false
+    });
+  }
+  /**
+   * Get a schema by IRI.
+   * For built-in schemas, this will lazy-load them on first access.
+   *
+   * @param iri - The schema IRI
+   * @returns The schema, or undefined if not found
+   */
+  async get(iri) {
+    const entry = this.schemas.get(iri);
+    if (entry) {
+      return entry.schema;
+    }
+    if (iri in builtInSchemas) {
+      const existingPromise = this.loadingPromises.get(iri);
+      if (existingPromise) {
+        return existingPromise;
+      }
+      const loadPromise = builtInSchemas[iri]().then((schema) => {
+        this.schemas.set(iri, { schema, builtIn: true });
+        this.loadingPromises.delete(iri);
+        return schema;
+      });
+      this.loadingPromises.set(iri, loadPromise);
+      return loadPromise;
+    }
+    if (this.remoteResolver) {
+      const existingPromise = this.loadingPromises.get(iri);
+      if (existingPromise) {
+        return existingPromise;
+      }
+      const loadPromise = this.remoteResolver(iri).then((definition) => {
+        if (!definition) return void 0;
+        const parsed = parseSchemaDefinition(definition);
+        if (!parsed) return void 0;
+        this.schemas.set(iri, { schema: parsed, builtIn: false });
+        return parsed;
+      }).catch(() => void 0).finally(() => {
+        this.loadingPromises.delete(iri);
+      });
+      this.loadingPromises.set(iri, loadPromise);
+      return loadPromise;
+    }
+    return void 0;
+  }
+  /**
+   * Get a schema synchronously (only works for already-loaded schemas).
+   *
+   * @param iri - The schema IRI
+   * @returns The schema, or undefined if not loaded
+   */
+  getSync(iri) {
+    return this.schemas.get(iri)?.schema;
+  }
+  /**
+   * Check if a schema is registered (either loaded or built-in).
+   */
+  has(iri) {
+    return this.schemas.has(iri) || iri in builtInSchemas;
+  }
+  /**
+   * Check if a schema is a built-in schema.
+   */
+  isBuiltIn(iri) {
+    return iri in builtInSchemas;
+  }
+  /**
+   * Get all registered schema IRIs (including built-in).
+   */
+  getAllIRIs() {
+    const iris = /* @__PURE__ */ new Set([
+      ...this.schemas.keys(),
+      ...Object.keys(builtInSchemas)
+    ]);
+    return Array.from(iris);
+  }
+  /**
+   * Unregister a custom schema.
+   * Built-in schemas cannot be unregistered.
+   *
+   * @param iri - The schema IRI to unregister
+   * @returns true if the schema was unregistered
+   */
+  unregister(iri) {
+    const entry = this.schemas.get(iri);
+    if (!entry || entry.builtIn) {
+      return false;
+    }
+    this.schemas.delete(iri);
+    return true;
+  }
+  /**
+   * Clear all custom schemas (keeps built-in schemas).
+   */
+  clear() {
+    for (const [iri, entry] of this.schemas) {
+      if (!entry.builtIn) {
+        this.schemas.delete(iri);
+      }
+    }
+  }
+  /**
+   * Set a remote resolver for fetching schemas by IRI.
+   * When a schema is not found locally, the resolver is queried.
+   */
+  setRemoteResolver(resolver) {
+    this.remoteResolver = resolver;
+  }
+  // ─── Version-Aware Methods ───────────────────────────────────────────────
+  /**
+   * Get the version of a registered schema.
+   *
+   * @param iri - The schema IRI (versioned or unversioned)
+   * @returns The version string, or undefined if not found
+   */
+  getVersion(iri) {
+    const entry = this.schemas.get(iri) ?? this.schemas.get(normalizeSchemaIRI(iri));
+    if (entry) {
+      return entry.schema.schema.version;
+    }
+    const normalizedIRI = normalizeSchemaIRI(iri);
+    if (normalizedIRI in builtInSchemas || iri in builtInSchemas) {
+      return "1.0.0";
+    }
+    return void 0;
+  }
+  /**
+   * Get all versions of a schema by its base name.
+   *
+   * @param baseIRI - The unversioned base IRI (e.g., 'xnet://xnet.fyi/Task')
+   * @returns Array of versioned schemas, sorted by version
+   */
+  getAllVersions(baseIRI) {
+    const versions = [];
+    const normalizedBase = getBaseSchemaIRI(baseIRI);
+    for (const [iri, entry] of this.schemas) {
+      if (getBaseSchemaIRI(iri) === normalizedBase) {
+        versions.push({
+          iri,
+          version: entry.schema.schema.version,
+          schema: entry.schema
+        });
+      }
+    }
+    for (const builtInIRI of Object.keys(builtInSchemas)) {
+      if (getBaseSchemaIRI(builtInIRI) === normalizedBase) {
+        const parsed = parseSchemaIRI(builtInIRI);
+        if (!versions.some((v) => v.iri === parsed.iri)) {
+          versions.push({
+            iri: parsed.iri,
+            version: parsed.version,
+            schema: void 0
+            // Placeholder
+          });
+        }
+      }
+    }
+    return versions.sort((a, b) => {
+      const [aMajor, aMinor, aPatch] = a.version.split(".").map(Number);
+      const [bMajor, bMinor, bPatch] = b.version.split(".").map(Number);
+      if (aMajor !== bMajor) return aMajor - bMajor;
+      if (aMinor !== bMinor) return aMinor - bMinor;
+      return aPatch - bPatch;
+    });
+  }
+  /**
+   * Parse a schema IRI into its components.
+   */
+  parseIRI(iri) {
+    return parseSchemaIRI(iri);
+  }
+};
+var isRecord = (value) => Boolean(value && typeof value === "object");
+var toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var toBoolean = (value) => typeof value === "boolean" ? value : void 0;
+var toStringValue = (value) => typeof value === "string" ? value : void 0;
+var toStringArray = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : void 0;
+var toRegExp = (value) => {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  try {
+    return new RegExp(value);
+  } catch {
+    return void 0;
+  }
+};
+var normalizeSelectOptions = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => isRecord(entry)).map((entry) => ({
+    id: typeof entry.id === "string" ? entry.id : "",
+    name: typeof entry.name === "string" ? entry.name : "",
+    ...typeof entry.color === "string" ? { color: entry.color } : {}
+  })).filter((entry) => entry.id.length > 0 && entry.name.length > 0);
+};
+var normalizePropertyDefinition = (definition, schemaId) => {
+  const name = typeof definition.name === "string" ? definition.name : "";
+  const type = typeof definition.type === "string" ? definition.type : "";
+  if (!name || !type) return null;
+  return {
+    "@id": typeof definition["@id"] === "string" ? definition["@id"] : `${schemaId}#${name}`,
+    name,
+    type: definition.type,
+    required: typeof definition.required === "boolean" ? definition.required : false,
+    ...isRecord(definition.config) ? { config: definition.config } : {}
+  };
+};
+var buildPropertyBuilder = (definition) => {
+  const config = isRecord(definition.config) ? definition.config : {};
+  const required = typeof definition.required === "boolean" ? definition.required : false;
+  switch (definition.type) {
+    case "text":
+      return text({
+        required,
+        minLength: toNumber(config.minLength),
+        maxLength: toNumber(config.maxLength),
+        pattern: toRegExp(config.pattern),
+        placeholder: toStringValue(config.placeholder)
+      });
+    case "number":
+      return number({
+        required,
+        min: toNumber(config.min),
+        max: toNumber(config.max),
+        integer: toBoolean(config.integer)
+      });
+    case "checkbox":
+      return checkbox({
+        required,
+        default: toBoolean(config.default)
+      });
+    case "date":
+      return date({
+        required,
+        includeTime: toBoolean(config.includeTime)
+      });
+    case "dateRange":
+      return dateRange({
+        required,
+        includeTime: toBoolean(config.includeTime)
+      });
+    case "select": {
+      const options = normalizeSelectOptions(config.options);
+      return select({
+        options,
+        required,
+        default: toStringValue(config.default)
+      });
+    }
+    case "multiSelect": {
+      const options = normalizeSelectOptions(config.options);
+      const defaultValue = toStringArray(config.default);
+      return multiSelect({
+        options,
+        required,
+        default: defaultValue
+      });
+    }
+    case "person":
+      return person({
+        required,
+        multiple: toBoolean(config.multiple)
+      });
+    case "relation":
+      return relation({
+        required,
+        multiple: toBoolean(config.multiple),
+        target: toStringValue(config.target)
+      });
+    case "url":
+      return url({
+        required,
+        placeholder: toStringValue(config.placeholder)
+      });
+    case "email":
+      return email({
+        required,
+        placeholder: toStringValue(config.placeholder)
+      });
+    case "phone":
+      return phone({
+        required,
+        placeholder: toStringValue(config.placeholder)
+      });
+    case "file":
+      return file({
+        required,
+        multiple: toBoolean(config.multiple),
+        accept: toStringArray(config.accept),
+        maxSize: toNumber(config.maxSize)
+      });
+    case "created":
+      return created({
+        label: toStringValue(config.label)
+      });
+    case "updated":
+      return updated({
+        label: toStringValue(config.label)
+      });
+    case "createdBy":
+      return createdBy({
+        label: toStringValue(config.label)
+      });
+    default:
+      return null;
+  }
+};
+var createDefinedSchema = (schema, properties) => {
+  const schemaId = schema["@id"];
+  const validate = (node) => {
+    const errors = [];
+    if (typeof node !== "object" || node === null) {
+      return { valid: false, errors: [{ path: "", message: "Node must be an object" }] };
+    }
+    const obj = node;
+    if (typeof obj.id !== "string") {
+      errors.push({ path: "id", message: "id is required and must be a string" });
+    }
+    if (obj.schemaId !== schemaId) {
+      errors.push({
+        path: "schemaId",
+        message: `schemaId must be '${schemaId}'`,
+        value: obj.schemaId
+      });
+    }
+    if (typeof obj.createdAt !== "number") {
+      errors.push({ path: "createdAt", message: "createdAt is required and must be a number" });
+    }
+    if (typeof obj.createdBy !== "string" || !obj.createdBy.startsWith("did:key:")) {
+      errors.push({ path: "createdBy", message: "createdBy must be a valid DID" });
+    }
+    for (const [name, builder] of Object.entries(properties)) {
+      const value = obj[name];
+      const isRequired = builder.definition.required;
+      if (value === void 0 || value === null) {
+        if (isRequired) {
+          errors.push({ path: name, message: `${name} is required` });
+        }
+      } else if (!builder.validate(value)) {
+        errors.push({ path: name, message: `${name} has invalid value`, value });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  };
+  const create = (props, createOptions) => {
+    const now = createOptions.createdAt ?? Date.now();
+    const id = createOptions.id ?? createNodeId();
+    const node = {
+      id,
+      schemaId,
+      createdAt: now,
+      createdBy: createOptions.createdBy
+    };
+    for (const [name, builder] of Object.entries(properties)) {
+      const rawValue = props[name];
+      const coerced = builder.coerce(rawValue);
+      if (coerced !== null) {
+        node[name] = coerced;
+      }
+    }
+    return node;
+  };
+  const is = (node) => node.schemaId === schemaId;
+  return {
+    schema,
+    validate,
+    create,
+    is,
+    _schemaId: schemaId,
+    _properties: properties
+  };
+};
+var parseSchemaDefinition = (definition) => {
+  if (!definition || typeof definition !== "object") return void 0;
+  if (typeof definition["@id"] !== "string") return void 0;
+  if (!Array.isArray(definition.properties)) return void 0;
+  const schemaId = definition["@id"];
+  const properties = definition.properties.map((prop) => normalizePropertyDefinition(prop, schemaId)).filter((prop) => prop !== null);
+  if (properties.length === 0) return void 0;
+  const propertyBuilders = {};
+  for (const property of properties) {
+    const builder = buildPropertyBuilder(property);
+    if (!builder) return void 0;
+    propertyBuilders[property.name] = builder;
+  }
+  const normalizedSchema = {
+    ...definition,
+    properties
+  };
+  return createDefinedSchema(normalizedSchema, propertyBuilders);
+};
+var schemaRegistry = new SchemaRegistry();
+
+// src/schema/system-index.ts
+var SystemSchemaIndex = class {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.options = options;
+  }
+  recordsByNodeId = /* @__PURE__ */ new Map();
+  recordsByIri = /* @__PURE__ */ new Map();
+  recordsByBaseIri = /* @__PURE__ */ new Map();
+  diagnosticsByNodeId = /* @__PURE__ */ new Map();
+  unsubscribe = null;
+  async initialize() {
+    await this.rebuild();
+    this.unsubscribe = this.store.subscribe((event) => {
+      this.applyChangeEvent(event);
+    });
+  }
+  async rebuild() {
+    this.recordsByNodeId.clear();
+    this.recordsByIri.clear();
+    this.recordsByBaseIri.clear();
+    this.diagnosticsByNodeId.clear();
+    const nodes = await this.store.list({ includeDeleted: false });
+    for (const node of nodes) {
+      this.indexNode(node);
+    }
+  }
+  resolve(iri) {
+    const normalized = normalizeSchemaIRI(iri);
+    const exact = this.recordsByIri.get(normalized) ?? this.recordsByIri.get(iri);
+    if (exact) {
+      return exact.definition;
+    }
+    const candidates = this.recordsByBaseIri.get(getBaseSchemaIRI(iri)) ?? [];
+    return candidates.at(-1)?.definition ?? null;
+  }
+  listDefinitions() {
+    return [...this.recordsByNodeId.values()].sort(
+      (left, right) => left.schemaIri.localeCompare(right.schemaIri)
+    );
+  }
+  getDiagnostics() {
+    return [...this.diagnosticsByNodeId.values()];
+  }
+  dispose() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    this.recordsByNodeId.clear();
+    this.recordsByIri.clear();
+    this.recordsByBaseIri.clear();
+    this.diagnosticsByNodeId.clear();
+  }
+  applyChangeEvent(event) {
+    if (event.previousNode && isSchemaDefinitionNode(event.previousNode)) {
+      this.removeNode(event.previousNode.id);
+    }
+    if (event.node && !event.node.deleted && isSchemaDefinitionNode(event.node)) {
+      this.indexNode(event.node);
+    }
+  }
+  indexNode(node) {
+    if (!isSchemaDefinitionNode(node)) {
+      return;
+    }
+    const validation = validateSchemaDefinitionNode(node, this.options);
+    if (!validation.valid) {
+      this.diagnosticsByNodeId.set(node.id, { nodeId: node.id, result: validation });
+      return;
+    }
+    const record = toSystemSchemaDefinitionRecord(node);
+    if (!record) {
+      return;
+    }
+    if (!this.options.includeDrafts && record.status !== "published") {
+      return;
+    }
+    this.recordsByNodeId.set(node.id, record);
+    this.recordsByIri.set(record.schemaIri, record);
+    this.recordsByIri.set(normalizeSchemaIRI(record.schemaIri), record);
+    const records = this.recordsByBaseIri.get(record.baseIri) ?? [];
+    records.push(record);
+    records.sort((left, right) => compareVersions(left.version, right.version));
+    this.recordsByBaseIri.set(record.baseIri, records);
+  }
+  removeNode(nodeId) {
+    const existing = this.recordsByNodeId.get(nodeId);
+    this.recordsByNodeId.delete(nodeId);
+    this.diagnosticsByNodeId.delete(nodeId);
+    if (!existing) {
+      return;
+    }
+    this.recordsByIri.delete(existing.schemaIri);
+    this.recordsByIri.delete(normalizeSchemaIRI(existing.schemaIri));
+    const remaining = (this.recordsByBaseIri.get(existing.baseIri) ?? []).filter(
+      (record) => record.nodeId !== nodeId
+    );
+    if (remaining.length === 0) {
+      this.recordsByBaseIri.delete(existing.baseIri);
+    } else {
+      this.recordsByBaseIri.set(existing.baseIri, remaining);
+    }
+  }
+};
+function createNodeGraphSchemaResolver(index) {
+  return async (iri) => index.resolve(iri);
+}
+function isSchemaDefinitionNode(node) {
+  return node.schemaId === SchemaDefinitionSchema.schema["@id"] || node.schemaId === "xnet://xnet.fyi/SchemaDefinition";
+}
+function toSystemSchemaDefinitionRecord(node) {
+  const schemaIri = asSchemaIri(node.properties.schemaIri);
+  const version = asString(node.properties.version);
+  const authority = asString(node.properties.authority);
+  const status = asSchemaDefinitionStatus(node.properties.status);
+  const publishedAt = asNumber(node.properties.publishedAt);
+  const definitionBytes = asString(node.properties.definitionBytes);
+  if (!schemaIri || !version || !authority || !status || publishedAt === null || !definitionBytes) {
+    return null;
+  }
+  const definition = parseSchemaDefinition2(definitionBytes);
+  if (!definition) {
+    return null;
+  }
+  return {
+    nodeId: node.id,
+    schemaIri,
+    baseIri: getBaseSchemaIRI(schemaIri),
+    version,
+    authority,
+    status,
+    publishedAt,
+    definition,
+    diagnostics: []
+  };
+}
+function parseSchemaDefinition2(definitionBytes) {
+  try {
+    const parsed = JSON.parse(definitionBytes);
+    if (!isRecord2(parsed)) return null;
+    if (typeof parsed["@id"] !== "string") return null;
+    if (typeof parsed["@type"] !== "string") return null;
+    if (typeof parsed.name !== "string") return null;
+    if (typeof parsed.namespace !== "string") return null;
+    if (typeof parsed.version !== "string") return null;
+    if (!Array.isArray(parsed.properties)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function compareVersions(left, right) {
+  const leftParsed = parseSemver(left);
+  const rightParsed = parseSemver(right);
+  for (let index = 0; index < leftParsed.length; index++) {
+    const diff = leftParsed[index] - rightParsed[index];
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return left.localeCompare(right);
+}
+function parseSemver(version) {
+  const parsed = version.split(/[+-]/)[0].split(".").map(Number);
+  return [
+    Number.isFinite(parsed[0]) ? parsed[0] : 0,
+    Number.isFinite(parsed[1]) ? parsed[1] : 0,
+    Number.isFinite(parsed[2]) ? parsed[2] : 0
+  ];
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asSchemaIri(value) {
+  if (typeof value !== "string" || !value.startsWith("xnet://")) {
+    return null;
+  }
+  const parsed = parseSchemaIRI(value);
+  return parsed.iri;
+}
+function asSchemaDefinitionStatus(value) {
+  return value === "draft" || value === "published" || value === "deprecated" || value === "revoked" ? value : null;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object");
+}
+
+// src/schema/presence.ts
+var PresenceAggregator = class {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.visibilityForNode = options.visibilityForNode ?? (() => "private");
+    this.now = options.now ?? Date.now;
+  }
+  visibilityForNode;
+  now;
+  unsubscribe = null;
+  rebuildQueued = false;
+  async initialize() {
+    await this.rebuild();
+    this.unsubscribe = this.store.subscribe((event) => {
+      if (isPresenceSummaryNode(event.node) || isPresenceSummaryNode(event.previousNode)) {
+        return;
+      }
+      void this.queueRebuild();
+    });
+  }
+  async rebuild() {
+    const nodes = await this.store.list({ includeDeleted: false });
+    const summaries = summarizePresenceNodes(nodes, {
+      visibilityForNode: this.visibilityForNode,
+      now: this.now
+    });
+    await this.upsertSummaries(summaries);
+    return summaries;
+  }
+  dispose() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+  async queueRebuild() {
+    if (this.rebuildQueued) {
+      return;
+    }
+    this.rebuildQueued = true;
+    await Promise.resolve();
+    this.rebuildQueued = false;
+    await this.rebuild();
+  }
+  async upsertSummaries(summaries) {
+    const existing = await this.store.list({ includeDeleted: false });
+    const existingById = new Map(
+      existing.filter(isPresenceSummaryNode).map((node) => [node.id, node])
+    );
+    const desiredIds = new Set(summaries.map((summary) => summary.id));
+    for (const summary of summaries) {
+      const existingSummary = existingById.get(summary.id);
+      const properties = {
+        subjectDid: summary.subjectDid,
+        schemaIri: summary.schemaIri,
+        namespace: summary.namespace,
+        countBucket: summary.countBucket,
+        visibility: summary.visibility,
+        lastUpdatedAt: summary.lastUpdatedAt,
+        sourcePolicy: summary.sourcePolicy,
+        noise: summary.noise
+      };
+      if (!existingSummary) {
+        await this.store.create({
+          id: summary.id,
+          schemaId: PresenceSummarySchema.schema["@id"],
+          properties
+        });
+        continue;
+      }
+      if (shouldUpdateSummary(existingSummary, properties)) {
+        await this.store.update(summary.id, { properties });
+      }
+    }
+    for (const existingSummary of existingById.values()) {
+      if (desiredIds.has(existingSummary.id)) {
+        continue;
+      }
+      const properties = createZeroPresenceSummaryProperties(existingSummary, this.now());
+      if (properties && shouldUpdateSummary(existingSummary, properties)) {
+        await this.store.update(existingSummary.id, { properties });
+      }
+    }
+  }
+};
+function summarizePresenceNodes(nodes, options = {}) {
+  const visibilityForNode = options.visibilityForNode ?? (() => "private");
+  const now = options.now ?? Date.now;
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.deleted || isPresenceSummaryNode(node)) {
+      continue;
+    }
+    const visibility = visibilityForNode(node);
+    const namespace = getNodeNamespace(node);
+    const key = `${node.createdBy}|${node.schemaId}|${namespace}|${visibility}`;
+    const existing = groups.get(key);
+    const count = (existing?.count ?? 0) + 1;
+    const subjectDid = node.createdBy;
+    const schemaIri = node.schemaId;
+    groups.set(key, {
+      count,
+      descriptor: {
+        id: buildPresenceSummaryId(subjectDid, schemaIri, namespace, visibility),
+        subjectDid,
+        schemaIri,
+        namespace,
+        countBucket: bucketPresenceCount(count, visibility),
+        visibility,
+        lastUpdatedAt: now(),
+        sourcePolicy: "node-derived",
+        noise: getPresenceNoisePolicy(visibility)
+      }
+    });
+  }
+  return [...groups.values()].map((entry) => ({
+    ...entry.descriptor,
+    countBucket: bucketPresenceCount(entry.count, entry.descriptor.visibility)
+  })).sort((left, right) => left.id.localeCompare(right.id));
+}
+function bucketPresenceCount(count, visibility = "private") {
+  const adjusted = visibility === "public-metadata" ? applyPublicPresenceNoise(count) : count;
+  if (adjusted <= 0) return "0";
+  if (adjusted === 1) return "1";
+  if (adjusted <= 5) return "2-5";
+  if (adjusted <= 20) return "6-20";
+  if (adjusted <= 100) return "21-100";
+  return "100+";
+}
+function getPresenceNoisePolicy(visibility) {
+  if (visibility === "public-metadata") {
+    return "bucketed:+1-threshold-noise";
+  }
+  return "bucketed";
+}
+function createZeroPresenceSummaryProperties(node, lastUpdatedAt) {
+  const subjectDid = asString2(node.properties.subjectDid);
+  const schemaIri = asString2(node.properties.schemaIri);
+  const namespace = asString2(node.properties.namespace);
+  const visibility = asPresenceVisibility(node.properties.visibility);
+  if (!subjectDid || !schemaIri || !namespace || !visibility) {
+    return null;
+  }
+  return {
+    subjectDid,
+    schemaIri,
+    namespace,
+    countBucket: "0",
+    visibility,
+    lastUpdatedAt,
+    sourcePolicy: "node-derived",
+    noise: getPresenceNoisePolicy(visibility)
+  };
+}
+function applyPublicPresenceNoise(count) {
+  if (count <= 1) {
+    return count;
+  }
+  return count + 1;
+}
+function buildPresenceSummaryId(subjectDid, schemaIri, namespace, visibility) {
+  return buildSystemNodeId(
+    subjectDid,
+    "presence",
+    `${encodeURIComponent(schemaIri)}:${encodeURIComponent(namespace)}:${visibility}`
+  );
+}
+function getNodeNamespace(node) {
+  const parsedSystem = node.id.match(/^(xnet:\/\/did:key:[^/]+\/sys\/[^/]+\/)/);
+  if (parsedSystem) {
+    return parsedSystem[1];
+  }
+  const parsedSchema = parseSchemaIRI(node.schemaId);
+  return parsedSchema.namespace || getBaseSchemaIRI(node.schemaId);
+}
+function isPresenceSummaryNode(node) {
+  return node !== null && node !== void 0 && (node.schemaId === PresenceSummarySchema.schema["@id"] || node.schemaId === "xnet://xnet.fyi/PresenceSummary");
+}
+function shouldUpdateSummary(existing, properties) {
+  return Object.entries(properties).some(([key, value]) => existing.properties[key] !== value);
+}
+function asString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function asPresenceVisibility(value) {
+  return value === "private" || value === "trusted-app" || value === "public-metadata" ? value : null;
+}
+
+// src/schema/lens.ts
+var MigrationError = class extends Error {
+  constructor(message, source, target) {
+    super(message);
+    this.source = source;
+    this.target = target;
+    this.name = "MigrationError";
+  }
+};
+var LensRegistry = class {
+  lenses = /* @__PURE__ */ new Map();
+  pathCache = /* @__PURE__ */ new Map();
+  /**
+   * Register a lens for transforming between two schema versions.
+   * Also registers the reverse transformation automatically.
+   */
+  register(lens) {
+    const forwardKey = `${lens.source}\u2192${lens.target}`;
+    this.lenses.set(forwardKey, lens);
+    const reverseLens = {
+      source: lens.target,
+      target: lens.source,
+      forward: lens.backward,
+      backward: lens.forward,
+      lossless: lens.lossless
+    };
+    const backwardKey = `${lens.target}\u2192${lens.source}`;
+    this.lenses.set(backwardKey, reverseLens);
+    this.pathCache.clear();
+  }
+  /**
+   * Unregister a lens (and its reverse).
+   */
+  unregister(source, target) {
+    const forwardKey = `${source}\u2192${target}`;
+    const backwardKey = `${target}\u2192${source}`;
+    const removedForward = this.lenses.delete(forwardKey);
+    const removedBackward = this.lenses.delete(backwardKey);
+    const removed = removedForward || removedBackward;
+    if (removed) {
+      this.pathCache.clear();
+    }
+    return removed;
+  }
+  /**
+   * Get a direct lens between two schemas (if registered).
+   */
+  get(source, target) {
+    return this.lenses.get(`${source}\u2192${target}`);
+  }
+  /**
+   * Check if a direct lens exists between two schemas.
+   */
+  has(source, target) {
+    return this.lenses.has(`${source}\u2192${target}`);
+  }
+  /**
+   * Find the shortest path of lenses between two schema versions.
+   * Uses BFS to find the optimal path through intermediate versions.
+   *
+   * @returns Array of lenses to apply in order, or null if no path exists
+   */
+  findPath(from, to) {
+    if (from === to) return [];
+    const cacheKey = `${from}\u2192${to}`;
+    if (this.pathCache.has(cacheKey)) {
+      return this.pathCache.get(cacheKey) ?? null;
+    }
+    const path = this.bfsPath(from, to);
+    this.pathCache.set(cacheKey, path);
+    return path;
+  }
+  /**
+   * Transform data from one schema version to another.
+   *
+   * @throws MigrationError if no path exists between schemas
+   */
+  transform(data, from, to) {
+    if (from === to) return data;
+    const path = this.findPath(from, to);
+    if (!path) {
+      throw new MigrationError(`No migration path from ${from} to ${to}`, from, to);
+    }
+    let result = data;
+    for (const lens of path) {
+      result = lens.forward(result);
+    }
+    return result;
+  }
+  /**
+   * Transform data with detailed migration result.
+   */
+  transformWithDetails(data, from, to) {
+    if (from === to) {
+      return { data, path: [], lossless: true, warnings: [] };
+    }
+    const path = this.findPath(from, to);
+    if (!path) {
+      throw new MigrationError(`No migration path from ${from} to ${to}`, from, to);
+    }
+    const warnings = [];
+    let result = data;
+    let allLossless = true;
+    for (const lens of path) {
+      result = lens.forward(result);
+      if (!lens.lossless) {
+        allLossless = false;
+        warnings.push(`Lossy transformation: ${lens.source} \u2192 ${lens.target}`);
+      }
+    }
+    return { data: result, path, lossless: allLossless, warnings };
+  }
+  /**
+   * Check if a migration path exists between two schemas.
+   */
+  canMigrate(from, to) {
+    return this.findPath(from, to) !== null;
+  }
+  /**
+   * Check if a migration path is lossless (all transformations preserve data).
+   */
+  isLossless(from, to) {
+    const path = this.findPath(from, to);
+    if (!path) return false;
+    return path.every((lens) => lens.lossless);
+  }
+  /**
+   * Get all registered schema IRIs.
+   */
+  getSchemas() {
+    const schemas = /* @__PURE__ */ new Set();
+    for (const lens of this.lenses.values()) {
+      schemas.add(lens.source);
+      schemas.add(lens.target);
+    }
+    return Array.from(schemas);
+  }
+  /**
+   * Clear all registered lenses and cached paths.
+   */
+  clear() {
+    this.lenses.clear();
+    this.pathCache.clear();
+  }
+  // ─── Private Methods ─────────────────────────────────────────────────────
+  /**
+   * BFS pathfinding to find shortest lens path between schemas.
+   */
+  bfsPath(from, to) {
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const lens of this.lenses.values()) {
+      const neighbors = adjacency.get(lens.source) ?? [];
+      neighbors.push({ target: lens.target, lens });
+      adjacency.set(lens.source, neighbors);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ schema: from, path: [] }];
+    while (queue.length > 0) {
+      const { schema, path } = queue.shift();
+      if (schema === to) {
+        return path;
+      }
+      if (visited.has(schema)) {
+        continue;
+      }
+      visited.add(schema);
+      const neighbors = adjacency.get(schema) ?? [];
+      for (const { target, lens } of neighbors) {
+        if (!visited.has(target)) {
+          queue.push({ schema: target, path: [...path, lens] });
+        }
+      }
+    }
+    return null;
+  }
+};
+var lensRegistry = new LensRegistry();
+
+// src/schema/lens-builders.ts
+function rename(from, to) {
+  return {
+    forward: (data) => {
+      const { [from]: value, ...rest } = data;
+      return value !== void 0 ? { ...rest, [to]: value } : rest;
+    },
+    backward: (data) => {
+      const { [to]: value, ...rest } = data;
+      return value !== void 0 ? { ...rest, [from]: value } : rest;
+    },
+    lossless: true
+  };
+}
+function convert(prop, forwardMap, backwardMap) {
+  return {
+    forward: (data) => {
+      const value = data[prop];
+      if (value === void 0) return data;
+      const key = String(value);
+      const mapped = forwardMap[key];
+      return mapped !== void 0 ? { ...data, [prop]: mapped } : data;
+    },
+    backward: (data) => {
+      const value = data[prop];
+      if (value === void 0) return data;
+      const key = String(value);
+      const mapped = backwardMap[key];
+      return mapped !== void 0 ? { ...data, [prop]: mapped } : data;
+    },
+    lossless: true
+  };
+}
+function promoteOverlay(authority, field, coreProp) {
+  return rename(extKey(authority, field), coreProp);
+}
+function addDefault(prop, defaultValue) {
+  return {
+    forward: (data) => ({
+      ...data,
+      [prop]: data[prop] ?? defaultValue
+    }),
+    backward: (data) => {
+      const { [prop]: _, ...rest } = data;
+      return rest;
+    },
+    lossless: false
+    // Data is lost in backward transform
+  };
+}
+function remove(prop) {
+  return {
+    forward: (data) => {
+      const { [prop]: _, ...rest } = data;
+      return rest;
+    },
+    backward: (data) => data,
+    // Cannot restore removed data
+    lossless: false
+    // Data is lost when property is removed
+  };
+}
+function transform(prop, forwardFn, backwardFn, options) {
+  return {
+    forward: (data) => {
+      const value = data[prop];
+      if (value === void 0) return data;
+      return { ...data, [prop]: forwardFn(value) };
+    },
+    backward: (data) => {
+      const value = data[prop];
+      if (value === void 0) return data;
+      return { ...data, [prop]: backwardFn(value) };
+    },
+    lossless: options?.lossless ?? true
+  };
+}
+function copy(from, to) {
+  return {
+    forward: (data) => {
+      const value = data[from];
+      return value !== void 0 ? { ...data, [to]: value } : data;
+    },
+    backward: (data) => {
+      const { [to]: _, ...rest } = data;
+      return rest;
+    },
+    lossless: true
+  };
+}
+function merge(fromProps, toProp, mergeFn, splitFn) {
+  return {
+    forward: (data) => {
+      const values = fromProps.map((prop) => data[prop]);
+      if (values.every((v) => v === void 0)) return data;
+      return { ...data, [toProp]: mergeFn(...values) };
+    },
+    backward: (data) => {
+      if (!splitFn) {
+        const { [toProp]: _, ...rest } = data;
+        return rest;
+      }
+      const value = data[toProp];
+      if (value === void 0) return data;
+      const values = splitFn(value);
+      const result = { ...data };
+      delete result[toProp];
+      fromProps.forEach((prop, i) => {
+        if (values[i] !== void 0) {
+          result[prop] = values[i];
+        }
+      });
+      return result;
+    },
+    lossless: splitFn !== void 0
+  };
+}
+function when(condition, operation) {
+  return {
+    forward: (data) => condition(data) ? operation.forward(data) : data,
+    backward: (data) => condition(data) ? operation.backward(data) : data,
+    lossless: operation.lossless
+  };
+}
+function composeLens(source, target, ...operations) {
+  return {
+    source,
+    target,
+    forward: (data) => operations.reduce((d, op) => op.forward(d), data),
+    backward: (data) => operations.reduceRight((d, op) => op.backward(d), data),
+    lossless: operations.every((op) => op.lossless !== false)
+  };
+}
+function createOperations(...operations) {
+  return {
+    forward: (data) => operations.reduce((d, op) => op.forward(d), data),
+    backward: (data) => operations.reduceRight((d, op) => op.backward(d), data),
+    lossless: operations.every((op) => op.lossless !== false)
+  };
+}
+function identity(source, target) {
+  return {
+    source,
+    target,
+    forward: (data) => data,
+    backward: (data) => data,
+    lossless: true
+  };
+}
+
+export {
+  TASK_SHORT_ID_PATTERN,
+  formatTaskShortId,
+  parseTaskShortId,
+  taskBranchName,
+  shortIdsFromBlock,
+  MAX_MENTION_DIDS,
+  normalizeMentions,
+  mentionsInclude,
+  isValidMentions,
+  createAccountRecord,
+  admitDeviceRecord,
+  nextEpoch,
+  revokeSubjectRecord,
+  revokeDeviceRecord,
+  accountState,
+  encodeAnchor,
+  decodeAnchor,
+  isTextAnchor,
+  isCellAnchor,
+  isRowAnchor,
+  isColumnAnchor,
+  isCanvasPositionAnchor,
+  isCanvasObjectAnchor,
+  isNodeAnchor,
+  extractMentions,
+  getMentionedUsers,
+  checkOrphanStatus,
+  filterOrphanedComments,
+  builtInSchemas,
+  buildEffectiveSchema,
+  lockedPropertyKeys,
+  canModifyColumn,
+  findLockedColumns,
+  selectExtensionFields,
+  loadExtensionFields,
+  resolveEffectiveSchema,
+  SIDECAR_PREFIX,
+  sidecarId,
+  sidecarOverlayKeys,
+  mergeSidecarsIntoRow,
+  SchemaRegistry,
+  schemaRegistry,
+  SystemSchemaIndex,
+  createNodeGraphSchemaResolver,
+  isSchemaDefinitionNode,
+  PresenceAggregator,
+  summarizePresenceNodes,
+  bucketPresenceCount,
+  getPresenceNoisePolicy,
+  MigrationError,
+  LensRegistry,
+  lensRegistry,
+  rename,
+  convert,
+  promoteOverlay,
+  addDefault,
+  remove,
+  transform,
+  copy,
+  merge,
+  when,
+  composeLens,
+  createOperations,
+  identity
+};