@xnetjs/data 0.0.2 → 0.0.3

package/dist/chunk-UDUPQKRB.js

@@ -0,0 +1,49 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-6OPZJ7MG.js";
+import {
+  checkbox,
+  defineSchema,
+  json,
+  number,
+  relation,
+  text
+} from "./chunk-O64EK5FK.js";
+
+// src/schema/schemas/database-field.ts
+var DatabaseFieldSchema = defineSchema({
+  name: "DatabaseField",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Parent database */
+    database: relation({
+      target: "xnet://xnet.fyi/Database@2.0.0",
+      required: true
+    }),
+    /** Display name */
+    name: text({ required: true, maxLength: 200 }),
+    /** Field type (FieldType union, enforced in field-operations) */
+    type: text({ required: true, maxLength: 50 }),
+    /**
+     * Type-specific configuration (FieldConfig).
+     * Note: select/multiSelect options are NOT stored here — they are
+     * separate DatabaseSelectOption nodes so concurrent option creation
+     * merges cleanly.
+     */
+    config: json({}),
+    /** Fractional index for default column ordering */
+    sortKey: text({ required: true }),
+    /** Default column width in pixels (table views) */
+    width: number({ min: 40, integer: true }),
+    /** Whether this is the title field (exactly one per database) */
+    isTitle: checkbox({}),
+    /** Hidden by default (views can override) */
+    hidden: checkbox({})
+  },
+  // Inherits access from its home Space (exploration 0181/0192).
+  authorization: spaceCascadeAuthorization("database")
+});
+
+export {
+  DatabaseFieldSchema
+};

package/dist/chunk-V6HZ3LF3.js

@@ -0,0 +1,380 @@
+import {
+  checkbox,
+  defineSchema,
+  number,
+  person,
+  select,
+  text
+} from "./chunk-O64EK5FK.js";
+
+// src/schema/schemas/system.ts
+import { base64ToBytes, hashHex, verify } from "@xnetjs/crypto";
+import { parseDID } from "@xnetjs/identity";
+var SCHEMA_STATUS_OPTIONS = [
+  { id: "draft", name: "Draft", color: "gray" },
+  { id: "published", name: "Published", color: "green" },
+  { id: "deprecated", name: "Deprecated", color: "yellow" },
+  { id: "revoked", name: "Revoked", color: "red" }
+];
+var COMPATIBILITY_MODE_OPTIONS = [
+  { id: "compatible", name: "Compatible", color: "green" },
+  { id: "requires-lens", name: "Requires Lens", color: "yellow" },
+  { id: "breaking", name: "Breaking", color: "red" }
+];
+var POLICY_STATUS_OPTIONS = [
+  { id: "active", name: "Active", color: "green" },
+  { id: "superseded", name: "Superseded", color: "yellow" },
+  { id: "revoked", name: "Revoked", color: "red" }
+];
+var PRESENCE_VISIBILITY_OPTIONS = [
+  { id: "private", name: "Private", color: "gray" },
+  { id: "trusted-app", name: "Trusted App", color: "blue" },
+  { id: "public-metadata", name: "Public Metadata", color: "green" }
+];
+var PRESENCE_COUNT_BUCKET_OPTIONS = [
+  { id: "0", name: "0", color: "gray" },
+  { id: "1", name: "1", color: "gray" },
+  { id: "2-5", name: "2-5", color: "blue" },
+  { id: "6-20", name: "6-20", color: "blue" },
+  { id: "21-100", name: "21-100", color: "green" },
+  { id: "100+", name: "100+", color: "green" }
+];
+var SCHEMA_IRI_PATTERN = /^xnet:\/\/[^/]+\/.+/;
+var SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+var CONTENT_HASH_PATTERN = /^cid:blake3:[0-9a-f]{64}$/;
+var SYSTEM_NAMESPACE_KINDS = ["schema", "compat", "policy", "presence", "authz"];
+var SchemaDefinitionSchema = defineSchema({
+  name: "SchemaDefinition",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    schemaIri: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    version: text({ required: true, pattern: SEMVER_PATTERN }),
+    authority: text({ required: true }),
+    definitionBytes: text({ required: true, minLength: 2 }),
+    contentHash: text({ required: true, pattern: CONTENT_HASH_PATTERN }),
+    publishedAt: number({ required: true, integer: true, min: 0 }),
+    status: select({ options: SCHEMA_STATUS_OPTIONS, required: true, default: "draft" }),
+    signature: text({ required: true, minLength: 80 }),
+    signingKeyId: text({ required: true }),
+    policyDefaults: text({}),
+    authorityProof: text({})
+  }
+});
+var SchemaCompatibilitySchema = defineSchema({
+  name: "SchemaCompatibility",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    fromSchema: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    toSchema: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    mode: select({ options: COMPATIBILITY_MODE_OPTIONS, required: true }),
+    lossless: checkbox({ default: false }),
+    lensRef: text({}),
+    validatedAt: number({ required: true, integer: true, min: 0 }),
+    validatedBy: person({})
+  }
+});
+var SyncPolicySchema = defineSchema({
+  name: "SyncPolicy",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    subjectDid: person({ required: true }),
+    matchRules: text({ required: true, minLength: 2 }),
+    destinations: text({ required: true, minLength: 2 }),
+    priority: number({ required: true, integer: true, min: 0 }),
+    revision: number({ required: true, integer: true, min: 1 }),
+    effectiveFrom: number({ required: true, integer: true, min: 0 }),
+    expiresAt: number({ integer: true, min: 0 }),
+    status: select({ options: POLICY_STATUS_OPTIONS, required: true, default: "active" })
+  }
+});
+var PresenceSummarySchema = defineSchema({
+  name: "PresenceSummary",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    subjectDid: person({ required: true }),
+    schemaIri: text({ required: true, pattern: SCHEMA_IRI_PATTERN }),
+    namespace: text({ required: true }),
+    countBucket: select({ options: PRESENCE_COUNT_BUCKET_OPTIONS, required: true }),
+    visibility: select({ options: PRESENCE_VISIBILITY_OPTIONS, required: true }),
+    lastUpdatedAt: number({ required: true, integer: true, min: 0 }),
+    sourcePolicy: text({}),
+    noise: text({})
+  }
+});
+var SYSTEM_SCHEMA_IRIS = {
+  SchemaDefinition: SchemaDefinitionSchema.schema["@id"],
+  SchemaCompatibility: SchemaCompatibilitySchema.schema["@id"],
+  SyncPolicy: SyncPolicySchema.schema["@id"],
+  PresenceSummary: PresenceSummarySchema.schema["@id"]
+};
+var SYSTEM_SCHEMA_BASE_IRIS = {
+  SchemaDefinition: "xnet://xnet.fyi/SchemaDefinition",
+  SchemaCompatibility: "xnet://xnet.fyi/SchemaCompatibility",
+  SyncPolicy: "xnet://xnet.fyi/SyncPolicy",
+  PresenceSummary: "xnet://xnet.fyi/PresenceSummary",
+  Grant: "xnet://xnet.fyi/Grant"
+};
+function isSystemSchemaIri(schemaIri) {
+  return Object.values(SYSTEM_SCHEMA_IRIS).some((iri) => schemaIri === iri) || Object.values(SYSTEM_SCHEMA_BASE_IRIS).some((iri) => schemaIri === iri);
+}
+function buildSystemNamespace(subjectDid, kind) {
+  return `xnet://${subjectDid}/sys/${kind}/`;
+}
+function buildSystemNodeId(subjectDid, kind, localId) {
+  return `${buildSystemNamespace(subjectDid, kind)}${localId.replace(/^\/+/, "")}`;
+}
+function parseSystemNamespaceResource(resource) {
+  const kinds = SYSTEM_NAMESPACE_KINDS.join("|");
+  const match = new RegExp(`^xnet://(did:key:[^/]+)/sys/(${kinds})(?:/(.*))?$`).exec(resource);
+  if (!match) {
+    return null;
+  }
+  const [, subjectDid, kind, localId = ""] = match;
+  return {
+    subjectDid,
+    kind,
+    namespace: buildSystemNamespace(subjectDid, kind),
+    localId
+  };
+}
+function isSystemNamespaceResource(resource) {
+  return parseSystemNamespaceResource(resource) !== null;
+}
+function resolveSchemaAuthority(options) {
+  const authority = extractSchemaIriAuthority(options.schemaIri);
+  const declaredAuthority = options.authority ?? authority ?? "";
+  const errors = [];
+  if (!authority) {
+    errors.push({
+      path: "schemaIri",
+      message: "schemaIri must use xnet://<authority>/<name> format",
+      value: options.schemaIri
+    });
+    return { valid: false, errors, kind: "invalid", authority: declaredAuthority };
+  }
+  if (declaredAuthority !== authority) {
+    errors.push({
+      path: "authority",
+      message: "authority must match schema IRI authority",
+      value: declaredAuthority
+    });
+  }
+  if (authority.startsWith("did:key:")) {
+    if (options.publisherDid && options.publisherDid !== authority) {
+      errors.push({
+        path: "publisherDid",
+        message: "DID authority schemas must be published by the authority DID",
+        value: options.publisherDid
+      });
+    }
+    return { valid: errors.length === 0, errors, kind: "did", authority };
+  }
+  if (!options.allowDomainAuthority) {
+    errors.push({
+      path: "schemaIri",
+      message: "domain authority schemas require explicit domain linkage policy",
+      value: options.schemaIri
+    });
+  }
+  if (options.allowDomainAuthority && !options.domainLinkageProof) {
+    errors.push({
+      path: "domainLinkageProof",
+      message: "domain authority schemas require a domain linkage proof"
+    });
+  }
+  return { valid: errors.length === 0, errors, kind: "domain", authority };
+}
+function computeSchemaDefinitionContentHash(definitionBytes) {
+  return `cid:blake3:${hashHex(new TextEncoder().encode(definitionBytes))}`;
+}
+function createSchemaDefinitionSigningPayload(input) {
+  return new TextEncoder().encode(canonicalJson(input));
+}
+function validateSchemaDefinitionNode(node, options = {}) {
+  const flattened = flattenNodeProperties(node);
+  const schemaResult = SchemaDefinitionSchema.validate(flattened);
+  const errors = [...schemaResult.errors];
+  const schemaIri = asString(flattened.schemaIri);
+  const version = asString(flattened.version);
+  const authority = asString(flattened.authority);
+  const definitionBytes = asString(flattened.definitionBytes);
+  const contentHash = asString(flattened.contentHash);
+  const signature = asString(flattened.signature);
+  const publishedAt = asNumber(flattened.publishedAt);
+  const status = asSchemaDefinitionStatus(flattened.status);
+  const authorityProof = asString(flattened.authorityProof);
+  if (schemaIri && authority) {
+    const authorityResult = resolveSchemaAuthority({
+      schemaIri,
+      authority,
+      publisherDid: options.publisherDid ?? asDid(flattened.createdBy),
+      allowDomainAuthority: options.allowDomainAuthority,
+      domainLinkageProof: options.domainLinkageProof ?? authorityProof ?? void 0
+    });
+    errors.push(...authorityResult.errors);
+  }
+  if (definitionBytes && contentHash) {
+    const expectedHash = computeSchemaDefinitionContentHash(definitionBytes);
+    if (contentHash !== expectedHash) {
+      errors.push({
+        path: "contentHash",
+        message: "contentHash must match definitionBytes",
+        value: contentHash
+      });
+    }
+    const parsedDefinition = parseSchemaJson(definitionBytes);
+    if (!parsedDefinition) {
+      errors.push({
+        path: "definitionBytes",
+        message: "definitionBytes must contain a valid JSON schema definition"
+      });
+    } else {
+      if (parsedDefinition["@id"] !== schemaIri) {
+        errors.push({
+          path: "definitionBytes.@id",
+          message: "embedded schema @id must match schemaIri",
+          value: parsedDefinition["@id"]
+        });
+      }
+      if (parsedDefinition.version !== version) {
+        errors.push({
+          path: "definitionBytes.version",
+          message: "embedded schema version must match version",
+          value: parsedDefinition.version
+        });
+      }
+    }
+  }
+  if (schemaIri && version && authority && contentHash && publishedAt !== null && status && signature) {
+    const signatureResult = validateSchemaDefinitionSignature({
+      signature,
+      authority,
+      authorityPublicKey: options.authorityPublicKey,
+      payload: createSchemaDefinitionSigningPayload({
+        schemaIri,
+        version,
+        authority,
+        contentHash,
+        publishedAt,
+        status
+      })
+    });
+    errors.push(...signatureResult.errors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateSchemaDefinitionSignature(input) {
+  const errors = [];
+  let signatureBytes;
+  try {
+    signatureBytes = base64ToBytes(input.signature);
+  } catch {
+    return {
+      valid: false,
+      errors: [{ path: "signature", message: "signature must be base64 encoded" }]
+    };
+  }
+  if (signatureBytes.length !== 64) {
+    errors.push({
+      path: "signature",
+      message: "signature must be an Ed25519 signature"
+    });
+  }
+  const publicKey = input.authorityPublicKey ?? getAuthorityPublicKey(input.authority);
+  if (publicKey && !verify(input.payload, signatureBytes, publicKey)) {
+    errors.push({
+      path: "signature",
+      message: "signature must verify against schema authority"
+    });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function getAuthorityPublicKey(authority) {
+  if (!authority.startsWith("did:key:")) {
+    return null;
+  }
+  try {
+    return parseDID(authority);
+  } catch {
+    return null;
+  }
+}
+function extractSchemaIriAuthority(schemaIri) {
+  const match = /^xnet:\/\/([^/]+)\/.+/.exec(schemaIri);
+  return match?.[1] ?? null;
+}
+function flattenNodeProperties(node) {
+  if (!isRecord(node)) {
+    return {};
+  }
+  if (isRecord(node.properties)) {
+    return {
+      id: node.id,
+      schemaId: node.schemaId,
+      createdAt: node.createdAt,
+      createdBy: node.createdBy,
+      ...node.properties
+    };
+  }
+  return node;
+}
+function parseSchemaJson(definitionBytes) {
+  try {
+    const parsed = JSON.parse(definitionBytes);
+    if (!isRecord(parsed)) return null;
+    if (typeof parsed["@id"] !== "string") return null;
+    if (typeof parsed.version !== "string") return null;
+    if (!Array.isArray(parsed.properties)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(sortKeys);
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, sortKeys(entry)])
+  );
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object");
+}
+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 asDid(value) {
+  return typeof value === "string" && value.startsWith("did:key:") ? value : void 0;
+}
+function asSchemaDefinitionStatus(value) {
+  return SCHEMA_STATUS_OPTIONS.some((option) => option.id === value) ? value : null;
+}
+
+export {
+  SYSTEM_NAMESPACE_KINDS,
+  SchemaDefinitionSchema,
+  SchemaCompatibilitySchema,
+  SyncPolicySchema,
+  PresenceSummarySchema,
+  SYSTEM_SCHEMA_IRIS,
+  SYSTEM_SCHEMA_BASE_IRIS,
+  isSystemSchemaIri,
+  buildSystemNamespace,
+  buildSystemNodeId,
+  parseSystemNamespaceResource,
+  isSystemNamespaceResource,
+  resolveSchemaAuthority,
+  computeSchemaDefinitionContentHash,
+  createSchemaDefinitionSigningPayload,
+  validateSchemaDefinitionNode
+};

package/dist/chunk-WMSCEBFH.js

@@ -0,0 +1,64 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-6OPZJ7MG.js";
+import {
+  date,
+  defineSchema,
+  person,
+  relation,
+  select,
+  text
+} from "./chunk-O64EK5FK.js";
+
+// src/schema/schemas/project.ts
+var ProjectSchema = defineSchema({
+  name: "Project",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Project name */
+    name: text({ required: true, maxLength: 200 }),
+    /** Emoji or icon URL */
+    icon: text({ maxLength: 500 }),
+    /** Project lifecycle status */
+    status: select({
+      options: [
+        { id: "planned", name: "Planned", color: "gray" },
+        { id: "in-progress", name: "In Progress", color: "blue" },
+        { id: "paused", name: "Paused", color: "yellow" },
+        { id: "completed", name: "Completed", color: "green" },
+        { id: "cancelled", name: "Cancelled", color: "red" }
+      ],
+      default: "planned"
+    }),
+    /** Project lead */
+    lead: person({}),
+    /** Target completion date */
+    targetDate: date({}),
+    /** 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 project brief
+  // Inherits access from its home Space (exploration 0181).
+  authorization: spaceCascadeAuthorization()
+});
+
+export {
+  ProjectSchema
+};

package/dist/chunk-WUR3WWQM.js

@@ -0,0 +1,65 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-6OPZJ7MG.js";
+import {
+  defineSchema,
+  json,
+  number,
+  relation,
+  text
+} from "./chunk-O64EK5FK.js";
+
+// src/schema/schemas/schema-extension.ts
+var SCHEMA_EXTENSION_SCHEMA_IRI = "xnet://xnet.fyi/SchemaExtension@1.0.0";
+var EXTENSION_FIELD_SCHEMA_IRI = "xnet://xnet.fyi/ExtensionField@1.0.0";
+var SchemaExtensionSchema = defineSchema({
+  name: "SchemaExtension",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Versioned IRI of the schema being extended, e.g. 'xnet://xnet.fyi/Contact@1.0.0' */
+    targetSchema: text({ required: true, maxLength: 300 }),
+    /**
+     * Namespace authority that owns these fields — a Space id, a DID, or a
+     * domain. Becomes the `<authority>` segment of every `ext:` key, so two
+     * tenants extending the same schema never collide.
+     */
+    authority: text({ required: true, maxLength: 200 }),
+    /** Human-readable label for the extension set (e.g. "Acme CRM fields") */
+    label: text({ maxLength: 200 }),
+    /** Optional owning Space — drives the authorization cascade for this overlay */
+    space: relation({ target: "xnet://xnet.fyi/Space@1.0.0" })
+  },
+  authorization: spaceCascadeAuthorization()
+});
+var ExtensionFieldSchema = defineSchema({
+  name: "ExtensionField",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Parent SchemaExtension */
+    extension: relation({ target: SCHEMA_EXTENSION_SCHEMA_IRI, required: true }),
+    /** Field token — the `<field>` segment of the `ext:<authority>/<field>` key */
+    name: text({ required: true, maxLength: 200 }),
+    /** Field type (FieldType union, enforced in field-operations) */
+    type: text({ required: true, maxLength: 50 }),
+    /** Type-specific configuration (FieldConfig) */
+    config: json({}),
+    /** Fractional index for ordering among a schema's extension fields */
+    sortKey: text({ required: true }),
+    /** Default column width in pixels (table views) */
+    width: number({ min: 40, integer: true }),
+    /** Optional owning Space — mirrors the parent extension's cascade */
+    space: relation({ target: "xnet://xnet.fyi/Space@1.0.0" })
+  },
+  authorization: spaceCascadeAuthorization()
+});
+function schemaExtensionId(authority, targetSchema) {
+  return `schemaext:${authority}:${targetSchema}`;
+}
+
+export {
+  SCHEMA_EXTENSION_SCHEMA_IRI,
+  EXTENSION_FIELD_SCHEMA_IRI,
+  SchemaExtensionSchema,
+  ExtensionFieldSchema,
+  schemaExtensionId
+};

package/dist/chunk-XHEA5UER.js

@@ -0,0 +1,75 @@
+// src/updates.ts
+import { sign, verify, hashHex } from "@xnetjs/crypto";
+import * as Y from "yjs";
+function signUpdate(options) {
+  const { update, authorDID, signingKey, parentHash, vectorClock } = options;
+  const updateHash = hashHex(update);
+  const timestamp = Date.now();
+  const signaturePayload = new TextEncoder().encode(
+    JSON.stringify({ updateHash, parentHash, authorDID, timestamp })
+  );
+  const signature = sign(signaturePayload, signingKey);
+  return {
+    update,
+    parentHash,
+    updateHash,
+    authorDID,
+    signature,
+    timestamp,
+    vectorClock
+  };
+}
+function verifyUpdate(update, getPublicKey) {
+  const publicKey = getPublicKey(update.authorDID);
+  if (!publicKey) return false;
+  const actualHash = hashHex(update.update);
+  if (actualHash !== update.updateHash) return false;
+  const signaturePayload = new TextEncoder().encode(
+    JSON.stringify({
+      updateHash: update.updateHash,
+      parentHash: update.parentHash,
+      authorDID: update.authorDID,
+      timestamp: update.timestamp
+    })
+  );
+  return verify(signaturePayload, update.signature, publicKey);
+}
+function applySignedUpdate(doc, update) {
+  Y.applyUpdate(doc, update.update);
+}
+function captureUpdate(doc, authorDID, signingKey, parentHash, vectorClock, callback) {
+  let capturedUpdate = null;
+  const handler = (update) => {
+    capturedUpdate = update;
+  };
+  doc.on("update", handler);
+  callback();
+  doc.off("update", handler);
+  if (!capturedUpdate) return null;
+  return signUpdate({
+    doc,
+    update: capturedUpdate,
+    authorDID,
+    signingKey,
+    parentHash,
+    vectorClock
+  });
+}
+function mergeDocuments(target, sources) {
+  for (const source of sources) {
+    const state = Y.encodeStateAsUpdate(source);
+    Y.applyUpdate(target, state);
+  }
+}
+function getMissingUpdates(doc, remoteStateVector) {
+  return Y.encodeStateAsUpdate(doc, remoteStateVector);
+}
+
+export {
+  signUpdate,
+  verifyUpdate,
+  applySignedUpdate,
+  captureUpdate,
+  mergeDocuments,
+  getMissingUpdates
+};