trellis 3.1.35 → 3.2.2

package/dist/chunk-44FFQKQX.js

@@ -0,0 +1,142 @@
+// src/schema/define.ts
+import { z } from "zod";
+function rel(target, cardinality = "one") {
+  return { target, cardinality };
+}
+function rollup(cfg) {
+  return { spec: { valueType: "rollup", rollup: cfg, computed: true, editable: false } };
+}
+function formula(expr) {
+  return { spec: { valueType: "formula", formula: expr, computed: true, editable: false } };
+}
+function defineType(type, shape, opts = {}) {
+  const relations = opts.relations ?? {};
+  const computed = opts.computed ?? {};
+  const fields = [
+    ...Object.entries(shape).map(
+      ([name, zt]) => zodToSpec(name, zt, name === opts.title)
+    ),
+    ...Object.entries(relations).map(([name, r]) => relationToSpec(name, r)),
+    ...Object.entries(computed).map(
+      ([name, c]) => ({ name, required: false, ...c.spec })
+    )
+  ];
+  const definition = {
+    "@id": `trellis:${type}`,
+    "@type": "trellis:Schema",
+    version: opts.version ?? "1.0.0",
+    tier: opts.tier ?? "user",
+    label: opts.label ?? type,
+    fields,
+    ...opts.extends ? { subClassOf: opts.extends } : {}
+  };
+  return {
+    type,
+    zod: z.object(shape),
+    relations,
+    computed,
+    definition,
+    toOntologySchema: () => lowerToLegacy(type, definition, relations)
+  };
+}
+function unwrap(zt) {
+  let t = zt;
+  for (let i = 0; i < 8; i++) {
+    if (t instanceof z.ZodOptional || t instanceof z.ZodNullable || t instanceof z.ZodDefault) {
+      const inner = t._def.innerType;
+      if (!inner) break;
+      t = inner;
+    } else {
+      break;
+    }
+  }
+  return t;
+}
+function zodToSpec(name, zt, isTitle) {
+  const required = !zt.isOptional();
+  const base = unwrap(zt);
+  let valueType = "rich_text";
+  let selectOptions;
+  if (isTitle) {
+    valueType = "title";
+  } else if (base instanceof z.ZodString) {
+    const checks = base._def.checks ?? [];
+    if (checks.some((c) => c.kind === "email")) valueType = "email";
+    else if (checks.some((c) => c.kind === "url")) valueType = "url";
+    else if (checks.some((c) => c.kind === "datetime")) valueType = "date";
+    else valueType = "rich_text";
+  } else if (base instanceof z.ZodNumber) {
+    valueType = "number";
+  } else if (base instanceof z.ZodBoolean) {
+    valueType = "checkbox";
+  } else if (base instanceof z.ZodDate) {
+    valueType = "date";
+  } else if (base instanceof z.ZodEnum) {
+    valueType = "select";
+    selectOptions = base.options.slice();
+  } else if (base instanceof z.ZodArray) {
+    const el = unwrap(base._def.type);
+    valueType = "multi_select";
+    if (el instanceof z.ZodEnum) {
+      selectOptions = el.options.slice();
+    }
+  } else {
+    valueType = "json";
+  }
+  const spec = { name, valueType, required };
+  if (selectOptions) spec.selectOptions = selectOptions;
+  return spec;
+}
+function targetName(r) {
+  return typeof r.target === "string" ? r.target : r.target().type;
+}
+function relationToSpec(name, r) {
+  return {
+    name,
+    valueType: "relation",
+    required: false,
+    relation: { targetSchema: targetName(r), cardinality: r.cardinality }
+  };
+}
+function attrType(v) {
+  switch (v) {
+    case "number":
+    case "rollup":
+      return "number";
+    case "checkbox":
+      return "boolean";
+    case "date":
+      return "date";
+    case "relation":
+      return "ref";
+    default:
+      return "string";
+  }
+}
+function lowerToLegacy(type, def, relations) {
+  const attributes = def.fields.filter((f) => f.valueType !== "relation").map((f) => ({
+    name: f.name,
+    type: attrType(f.valueType),
+    required: f.required ?? false
+  }));
+  const rels = Object.entries(relations).map(([name, r]) => ({
+    name,
+    sourceTypes: [type],
+    targetTypes: [targetName(r)],
+    cardinality: r.cardinality
+  }));
+  return {
+    id: def["@id"],
+    name: type,
+    version: def.version,
+    entities: [{ name: type, attributes }],
+    relations: rels
+  };
+}
+
+export {
+  rel,
+  rollup,
+  formula,
+  defineType
+};

package/dist/chunk-4HYPLFJD.js

@@ -0,0 +1,150 @@
+import {
+  __esm,
+  __export
+} from "./chunk-KFQGP6VL.js";
+
+// src/sync/reconciler.ts
+var reconciler_exports = {};
+__export(reconciler_exports, {
+  findForkPoint: () => findForkPoint,
+  reconcile: () => reconcile
+});
+function findForkPoint(opsA, opsB) {
+  const hashesB = new Set(opsB.map((o) => o.hash));
+  let forkPoint = null;
+  for (const op of opsA) {
+    if (hashesB.has(op.hash)) {
+      forkPoint = op.hash;
+    }
+  }
+  return forkPoint;
+}
+function reconcile(opsA, opsB) {
+  const forkPoint = findForkPoint(opsA, opsB);
+  const hashesA = new Set(opsA.map((o) => o.hash));
+  const hashesB = new Set(opsB.map((o) => o.hash));
+  const shared = [];
+  const uniqueToA = [];
+  const uniqueToB = [];
+  for (const op of opsA) {
+    if (hashesB.has(op.hash)) {
+      shared.push(op);
+    } else {
+      uniqueToA.push(op);
+    }
+  }
+  for (const op of opsB) {
+    if (!hashesA.has(op.hash)) {
+      uniqueToB.push(op);
+    }
+  }
+  if (uniqueToA.length === 0) {
+    return {
+      merged: [...shared, ...uniqueToB],
+      uniqueToA: [],
+      uniqueToB,
+      forkPoint,
+      clean: true,
+      conflicts: []
+    };
+  }
+  if (uniqueToB.length === 0) {
+    return {
+      merged: [...shared, ...uniqueToA],
+      uniqueToA,
+      uniqueToB: [],
+      forkPoint,
+      clean: true,
+      conflicts: []
+    };
+  }
+  const conflicts = detectConflicts(uniqueToA, uniqueToB);
+  const interleaved = interleaveByTimestamp(uniqueToA, uniqueToB);
+  return {
+    merged: [...shared, ...interleaved],
+    uniqueToA,
+    uniqueToB,
+    forkPoint,
+    clean: conflicts.length === 0,
+    conflicts
+  };
+}
+function detectConflicts(uniqueA, uniqueB) {
+  const conflicts = [];
+  const aMutations = /* @__PURE__ */ new Map();
+  for (const op of uniqueA) {
+    if (!FILE_MUTATION_KINDS.has(op.kind) || !op.vcs?.filePath) continue;
+    const path = op.vcs.filePath;
+    if (!aMutations.has(path)) aMutations.set(path, []);
+    aMutations.get(path).push(op);
+  }
+  for (const op of uniqueB) {
+    if (!FILE_MUTATION_KINDS.has(op.kind) || !op.vcs?.filePath) continue;
+    const path = op.vcs.filePath;
+    const aOps = aMutations.get(path);
+    if (!aOps) continue;
+    for (const aOp of aOps) {
+      if (aOp.kind === "vcs:fileModify" && op.kind === "vcs:fileModify") {
+        conflicts.push({
+          opA: aOp,
+          opB: op,
+          filePath: path,
+          reason: `Both sides modified ${path}`
+        });
+      } else if (aOp.kind === "vcs:fileDelete" && op.kind === "vcs:fileModify" || aOp.kind === "vcs:fileModify" && op.kind === "vcs:fileDelete") {
+        conflicts.push({
+          opA: aOp,
+          opB: op,
+          filePath: path,
+          reason: `Delete/modify conflict on ${path}`
+        });
+      } else if (aOp.kind === "vcs:fileAdd" && op.kind === "vcs:fileAdd") {
+        if (aOp.vcs?.contentHash !== op.vcs?.contentHash) {
+          conflicts.push({
+            opA: aOp,
+            opB: op,
+            filePath: path,
+            reason: `Both sides added ${path} with different content`
+          });
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function interleaveByTimestamp(a, b) {
+  const result = [];
+  let ai = 0;
+  let bi = 0;
+  while (ai < a.length && bi < b.length) {
+    const tA = new Date(a[ai].timestamp).getTime();
+    const tB = new Date(b[bi].timestamp).getTime();
+    if (tA <= tB) {
+      result.push(a[ai++]);
+    } else {
+      result.push(b[bi++]);
+    }
+  }
+  while (ai < a.length) result.push(a[ai++]);
+  while (bi < b.length) result.push(b[bi++]);
+  return result;
+}
+var FILE_MUTATION_KINDS;
+var init_reconciler = __esm({
+  "src/sync/reconciler.ts"() {
+    "use strict";
+    FILE_MUTATION_KINDS = /* @__PURE__ */ new Set([
+      "vcs:fileAdd",
+      "vcs:fileModify",
+      "vcs:fileDelete",
+      "vcs:fileRename"
+    ]);
+  }
+});
+
+export {
+  findForkPoint,
+  reconcile,
+  reconciler_exports,
+  init_reconciler
+};

package/dist/chunk-4XIVMVHC.js

@@ -0,0 +1,361 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/core/store/eav-store.ts
+function* flatten(obj, base = "") {
+  if (Array.isArray(obj)) {
+    for (const v of obj) {
+      yield* flatten(v, base);
+    }
+  } else if (obj && typeof obj === "object") {
+    for (const [k, v] of Object.entries(obj)) {
+      yield* flatten(v, base ? `${base}.${k}` : k);
+    }
+  } else {
+    yield [base, obj];
+  }
+}
+function jsonEntityFacts(entityId, root, type) {
+  const facts = [{ e: entityId, a: "type", v: type }];
+  for (const [a, v] of flatten(root)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v)) {
+      for (const el of v) {
+        facts.push({ e: entityId, a, v: el });
+      }
+    } else if (typeof v === "object") {
+    } else {
+      facts.push({ e: entityId, a, v });
+    }
+  }
+  return facts;
+}
+var EAVStore;
+var init_eav_store = __esm({
+  "src/core/store/eav-store.ts"() {
+    "use strict";
+    EAVStore = class {
+      facts = [];
+      links = [];
+      catalog = /* @__PURE__ */ new Map();
+      // Indexes for fast lookups
+      eavIndex = /* @__PURE__ */ new Map();
+      aevIndex = /* @__PURE__ */ new Map();
+      aveIndex = /* @__PURE__ */ new Map();
+      // Link indexes for graph queries
+      linkIndex = /* @__PURE__ */ new Map();
+      // e1 -> a -> e2s
+      linkReverseIndex = /* @__PURE__ */ new Map();
+      // e2 -> a -> e1s
+      linkAttrIndex = /* @__PURE__ */ new Map();
+      // a -> [(e1, e2)]
+      // Distinct value tracking
+      distinct = /* @__PURE__ */ new Map();
+      // attr -> set of valueKey
+      addFacts(facts) {
+        for (let i = 0; i < facts.length; i++) {
+          const fact = facts[i];
+          if (fact) {
+            if (this.hasFact(fact.e, fact.a, fact.v)) {
+              continue;
+            }
+            this.facts.push(fact);
+            this.updateIndexes(fact, this.facts.length - 1);
+            this.updateCatalog(fact);
+          }
+        }
+      }
+      /**
+       * Check if a fact already exists in the store.
+       */
+      hasFact(entity, attribute, value) {
+        const valueKey = this.valueKey(value);
+        const indices = this.aveIndex.get(attribute)?.get(valueKey);
+        if (!indices) return false;
+        for (const idx of indices) {
+          const fact = this.facts[idx];
+          if (fact && fact.e === entity && fact.a === attribute) {
+            return true;
+          }
+        }
+        return false;
+      }
+      addLinks(links) {
+        for (const link of links) {
+          this.links.push(link);
+          this.updateLinkIndexes(link);
+        }
+      }
+      deleteFacts(factsToDelete) {
+        for (const fact of factsToDelete) {
+          const valueKey = this.valueKey(fact.v);
+          const indices = this.aveIndex.get(fact.a)?.get(valueKey);
+          if (!indices) continue;
+          let foundIdx = -1;
+          for (const idx of indices) {
+            const storedFact = this.facts[idx];
+            if (storedFact && storedFact.e === fact.e && storedFact.a === fact.a) {
+              foundIdx = idx;
+              break;
+            }
+          }
+          if (foundIdx !== -1) {
+            this.facts[foundIdx] = void 0;
+            this.eavIndex.get(fact.e)?.get(fact.a)?.delete(foundIdx);
+            this.aevIndex.get(fact.a)?.get(fact.e)?.delete(foundIdx);
+            this.aveIndex.get(fact.a)?.get(valueKey)?.delete(foundIdx);
+            const entry = this.catalog.get(fact.a);
+            if (entry) {
+            }
+          }
+        }
+      }
+      deleteLinks(linksToDelete) {
+        for (const link of linksToDelete) {
+          const initialLen = this.links.length;
+          this.links = this.links.filter(
+            (l) => !(l.e1 === link.e1 && l.a === link.a && l.e2 === link.e2)
+          );
+          if (this.links.length < initialLen) {
+            this.linkIndex.get(link.e1)?.get(link.a)?.delete(link.e2);
+            this.linkReverseIndex.get(link.e2)?.get(link.a)?.delete(link.e1);
+            const attrPairs = this.linkAttrIndex.get(link.a);
+            if (attrPairs) {
+              for (const pair of attrPairs) {
+                if (pair[0] === link.e1 && pair[1] === link.e2) {
+                  attrPairs.delete(pair);
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+      updateIndexes(fact, index) {
+        if (!this.eavIndex.has(fact.e)) {
+          this.eavIndex.set(fact.e, /* @__PURE__ */ new Map());
+        }
+        if (!this.eavIndex.get(fact.e).has(fact.a)) {
+          this.eavIndex.get(fact.e).set(fact.a, /* @__PURE__ */ new Set());
+        }
+        this.eavIndex.get(fact.e).get(fact.a).add(index);
+        if (!this.aevIndex.has(fact.a)) {
+          this.aevIndex.set(fact.a, /* @__PURE__ */ new Map());
+        }
+        if (!this.aevIndex.get(fact.a).has(fact.e)) {
+          this.aevIndex.get(fact.a).set(fact.e, /* @__PURE__ */ new Set());
+        }
+        this.aevIndex.get(fact.a).get(fact.e).add(index);
+        if (!this.aveIndex.has(fact.a)) {
+          this.aveIndex.set(fact.a, /* @__PURE__ */ new Map());
+        }
+        const valueKey = this.valueKey(fact.v);
+        if (!this.aveIndex.get(fact.a).has(valueKey)) {
+          this.aveIndex.get(fact.a).set(valueKey, /* @__PURE__ */ new Set());
+        }
+        this.aveIndex.get(fact.a).get(valueKey).add(index);
+      }
+      updateLinkIndexes(link) {
+        if (!this.linkIndex.has(link.e1)) {
+          this.linkIndex.set(link.e1, /* @__PURE__ */ new Map());
+        }
+        const e1Attrs = this.linkIndex.get(link.e1);
+        if (!e1Attrs.has(link.a)) {
+          e1Attrs.set(link.a, /* @__PURE__ */ new Set());
+        }
+        e1Attrs.get(link.a).add(link.e2);
+        if (!this.linkReverseIndex.has(link.e2)) {
+          this.linkReverseIndex.set(link.e2, /* @__PURE__ */ new Map());
+        }
+        const e2Attrs = this.linkReverseIndex.get(link.e2);
+        if (!e2Attrs.has(link.a)) {
+          e2Attrs.set(link.a, /* @__PURE__ */ new Set());
+        }
+        e2Attrs.get(link.a).add(link.e1);
+        if (!this.linkAttrIndex.has(link.a)) {
+          this.linkAttrIndex.set(link.a, /* @__PURE__ */ new Set());
+        }
+        this.linkAttrIndex.get(link.a).add([link.e1, link.e2]);
+      }
+      valueKey(v) {
+        if (v instanceof Date) return `date:${v.toISOString()}`;
+        return `${typeof v}:${v}`;
+      }
+      updateCatalog(fact) {
+        const entry = this.catalog.get(fact.a) || {
+          attribute: fact.a,
+          type: this.inferType(fact.v),
+          cardinality: "one",
+          distinctCount: 0,
+          examples: []
+        };
+        const factType = this.inferType(fact.v);
+        if (entry.type !== factType && entry.type !== "mixed") {
+          entry.type = "mixed";
+        }
+        const entityAttrs = this.eavIndex.get(fact.e)?.get(fact.a);
+        if (entityAttrs && entityAttrs.size > 1) {
+          entry.cardinality = "many";
+        }
+        const k = this.valueKey(fact.v);
+        const s = this.distinct.get(fact.a) || (this.distinct.set(fact.a, /* @__PURE__ */ new Set()), this.distinct.get(fact.a));
+        s.add(k);
+        entry.distinctCount = s.size;
+        if (entry.examples.length < 5 && !entry.examples.includes(fact.v)) {
+          entry.examples.push(fact.v);
+        }
+        if (typeof fact.v === "number") {
+          entry.min = Math.min(entry.min ?? fact.v, fact.v);
+          entry.max = Math.max(entry.max ?? fact.v, fact.v);
+        }
+        this.catalog.set(fact.a, entry);
+      }
+      inferType(v) {
+        if (typeof v === "string") return "string";
+        if (typeof v === "number") return "number";
+        if (typeof v === "boolean") return "boolean";
+        if (v instanceof Date) return "date";
+        return "mixed";
+      }
+      // Query methods
+      getFactsByEntity(entity) {
+        const indices = this.eavIndex.get(entity);
+        if (!indices) return [];
+        const result = [];
+        for (const attrIndices of indices.values()) {
+          for (const idx of attrIndices) {
+            const fact = this.facts[idx];
+            if (fact) {
+              result.push(fact);
+            }
+          }
+        }
+        return result;
+      }
+      getFactsByAttribute(attribute) {
+        const indices = this.aevIndex.get(attribute);
+        if (!indices) return [];
+        const result = [];
+        for (const entityIndices of indices.values()) {
+          for (const idx of entityIndices) {
+            const fact = this.facts[idx];
+            if (fact) {
+              result.push(fact);
+            }
+          }
+        }
+        return result;
+      }
+      getFactsByValue(attribute, value) {
+        const indices = this.aveIndex.get(attribute)?.get(this.valueKey(value));
+        if (!indices) return [];
+        return Array.from(indices).map((idx) => this.facts[idx]).filter((fact) => fact !== void 0);
+      }
+      getCatalog() {
+        return Array.from(this.catalog.values());
+      }
+      getCatalogEntry(attribute) {
+        return this.catalog.get(attribute);
+      }
+      // Statistics
+      getAllFacts() {
+        return this.facts.filter((f) => f !== void 0);
+      }
+      getAllLinks() {
+        return [...this.links];
+      }
+      getLinksByEntity(entity) {
+        const results = [];
+        const forwardLinks = this.linkIndex.get(entity);
+        if (forwardLinks) {
+          for (const [attr, targets] of forwardLinks) {
+            for (const target of targets) {
+              results.push({ e1: entity, a: attr, e2: target });
+            }
+          }
+        }
+        const reverseLinks = this.linkReverseIndex.get(entity);
+        if (reverseLinks) {
+          for (const [attr, sources] of reverseLinks) {
+            for (const source of sources) {
+              results.push({ e1: source, a: attr, e2: entity });
+            }
+          }
+        }
+        return results;
+      }
+      getLinksByAttribute(attribute) {
+        const results = [];
+        const links = this.linkAttrIndex.get(attribute);
+        if (links) {
+          for (const [e1, e2] of links) {
+            results.push({ e1, a: attribute, e2 });
+          }
+        }
+        return results;
+      }
+      getLinksByEntityAndAttribute(entity, attribute) {
+        const results = [];
+        const attrs = this.linkIndex.get(entity);
+        if (attrs) {
+          const targets = attrs.get(attribute);
+          if (targets) {
+            for (const target of targets) {
+              results.push({ e1: entity, a: attribute, e2: target });
+            }
+          }
+        }
+        return results;
+      }
+      getStats() {
+        return {
+          totalFacts: this.facts.length,
+          totalLinks: this.links.length,
+          uniqueEntities: this.eavIndex.size,
+          uniqueAttributes: this.aevIndex.size,
+          catalogEntries: this.catalog.size
+        };
+      }
+      /**
+       * Creates a serializable snapshot of the current store state.
+       */
+      snapshot() {
+        return {
+          facts: this.facts.filter((f) => f !== void 0),
+          links: [...this.links],
+          catalog: this.getCatalog()
+        };
+      }
+      /**
+       * Restores the store state from a snapshot and rebuilds all indexes.
+       */
+      restore(snapshot) {
+        this.facts = [];
+        this.links = [];
+        this.catalog.clear();
+        this.eavIndex.clear();
+        this.aevIndex.clear();
+        this.aveIndex.clear();
+        this.linkIndex.clear();
+        this.linkReverseIndex.clear();
+        this.linkAttrIndex.clear();
+        this.distinct.clear();
+        this.addFacts(snapshot.facts);
+        this.addLinks(snapshot.links);
+        if (snapshot.catalog) {
+          for (const entry of snapshot.catalog) {
+            this.catalog.set(entry.attribute, entry);
+          }
+        }
+      }
+    };
+  }
+});
+
+export {
+  flatten,
+  jsonEntityFacts,
+  EAVStore,
+  init_eav_store
+};