trellis 3.2.0 → 3.2.2

package/dist/chunk-BJ5EKCJ5.js

@@ -1,458 +0,0 @@
-import {
-  init_reconciler,
-  reconcile
-} from "./chunk-4HYPLFJD.js";
-
-// src/sync/types.ts
-var PROTOCOL_VERSION = 1;
-var MIN_SUPPORTED_VERSION = 1;
-var MAX_SUPPORTED_VERSION = 1;
-
-// src/sync/sync-engine.ts
-init_reconciler();
-var SyncEngine = class {
-  localPeerId;
-  state;
-  transport;
-  getLocalOps;
-  onOpsReceived;
-  onNackReceived;
-  branchPolicy;
-  constructor(opts) {
-    this.localPeerId = opts.localPeerId;
-    this.transport = opts.transport;
-    this.getLocalOps = opts.getLocalOps;
-    this.onOpsReceived = opts.onOpsReceived;
-    this.onNackReceived = opts.onNackReceived;
-    this.branchPolicy = opts.branchPolicy ?? { linear: true };
-    this.state = {
-      localPeerId: opts.localPeerId,
-      peerHeads: /* @__PURE__ */ new Map(),
-      pendingAcks: /* @__PURE__ */ new Set(),
-      lastSync: /* @__PURE__ */ new Map()
-    };
-    this.transport.onMessage((msg) => this.handleMessage(msg));
-  }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-  /**
-   * Initiate a sync with a specific peer.
-   * Sends a 'have' message advertising our heads.
-   */
-  async pushTo(peerId) {
-    const ops = this.getLocalOps();
-    const heads = {};
-    if (ops.length > 0) {
-      heads["main"] = ops[ops.length - 1].hash;
-    }
-    await this.transport.send(peerId, {
-      version: PROTOCOL_VERSION,
-      type: "have",
-      peerId: this.localPeerId,
-      heads,
-      opCount: ops.length
-    });
-  }
-  /**
-   * Request ops from a peer.
-   */
-  async pullFrom(peerId) {
-    const ops = this.getLocalOps();
-    const lastHash = ops.length > 0 ? ops[ops.length - 1].hash : void 0;
-    await this.transport.send(peerId, {
-      version: PROTOCOL_VERSION,
-      type: "want",
-      peerId: this.localPeerId,
-      wantHashes: [],
-      afterHash: lastHash
-    });
-  }
-  /**
-   * Request the peer's complete op set and rely on hash dedupe during ingest.
-   */
-  async pullAllFrom(peerId) {
-    await this.transport.send(peerId, {
-      version: PROTOCOL_VERSION,
-      type: "want",
-      peerId: this.localPeerId,
-      wantHashes: []
-    });
-  }
-  /**
-   * Send all our ops to a peer (full push).
-   */
-  async sendOps(peerId, ops) {
-    const opsToSend = ops ?? this.getLocalOps();
-    await this.sendOpsMessage(peerId, opsToSend);
-  }
-  /**
-   * Internal: send an `ops` message and track outbound hashes in
-   * `pendingAcks` until the receiver acks or nacks them. All three sites
-   * that emit `ops` (sendOps, handleHave, handleWant) route through here so
-   * pendingAcks reflects every outbound op uniformly.
-   */
-  async sendOpsMessage(peerId, ops) {
-    if (ops.length === 0) return;
-    for (const op of ops) {
-      this.state.pendingAcks.add(op.hash);
-    }
-    await this.transport.send(peerId, {
-      version: PROTOCOL_VERSION,
-      type: "ops",
-      peerId: this.localPeerId,
-      ops
-    });
-  }
-  /**
-   * Reconcile our ops with a remote peer's ops.
-   */
-  reconcileWith(remoteOps) {
-    const localOps = this.getLocalOps();
-    return reconcile(localOps, remoteOps);
-  }
-  /**
-   * Get current sync state.
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Get branch policy.
-   */
-  getBranchPolicy() {
-    return this.branchPolicy;
-  }
-  /**
-   * Set branch policy.
-   */
-  setBranchPolicy(policy) {
-    this.branchPolicy = policy;
-  }
-  /**
-   * List known peers.
-   */
-  listPeers() {
-    return this.transport.peers();
-  }
-  // -------------------------------------------------------------------------
-  // Message handling
-  // -------------------------------------------------------------------------
-  async handleMessage(msg) {
-    if (typeof msg.version !== "number" || msg.version < MIN_SUPPORTED_VERSION || msg.version > MAX_SUPPORTED_VERSION) {
-      await this.transport.send(msg.peerId, {
-        version: PROTOCOL_VERSION,
-        type: "nack",
-        peerId: this.localPeerId,
-        refs: [],
-        reason: "protocol-version",
-        details: `Unsupported protocol version ${msg.version}; supported range is ${MIN_SUPPORTED_VERSION}-${MAX_SUPPORTED_VERSION}.`
-      });
-      return;
-    }
-    switch (msg.type) {
-      case "have":
-        await this.handleHave(msg);
-        break;
-      case "want":
-        await this.handleWant(msg);
-        break;
-      case "ops":
-        await this.handleOps(msg);
-        break;
-      case "ack":
-        this.handleAck(msg);
-        break;
-      case "nack":
-        await this.handleNack(msg);
-        break;
-    }
-  }
-  async handleHave(msg) {
-    this.state.peerHeads.set(msg.peerId, msg.heads);
-    const localOps = this.getLocalOps();
-    const localHashes = new Set(localOps.map((o) => o.hash));
-    for (const [, hash] of Object.entries(msg.heads)) {
-      if (!localHashes.has(hash)) {
-        const afterHash = msg.opCount > localOps.length ? void 0 : localOps.length > 0 ? localOps[localOps.length - 1].hash : void 0;
-        await this.transport.send(msg.peerId, {
-          version: PROTOCOL_VERSION,
-          type: "want",
-          peerId: this.localPeerId,
-          wantHashes: [],
-          afterHash
-        });
-        return;
-      }
-    }
-    if (msg.opCount > localOps.length) {
-      await this.transport.send(msg.peerId, {
-        version: PROTOCOL_VERSION,
-        type: "want",
-        peerId: this.localPeerId,
-        wantHashes: []
-      });
-      return;
-    }
-    const peerOpCount = msg.opCount;
-    if (localOps.length > peerOpCount) {
-      await this.sendOpsMessage(msg.peerId, localOps.slice(peerOpCount));
-    }
-  }
-  async handleWant(msg) {
-    const localOps = this.getLocalOps();
-    let opsToSend;
-    if (msg.afterHash) {
-      const idx = localOps.findIndex((o) => o.hash === msg.afterHash);
-      opsToSend = idx >= 0 ? localOps.slice(idx + 1) : localOps;
-    } else if (msg.wantHashes.length > 0) {
-      const wanted = new Set(msg.wantHashes);
-      opsToSend = localOps.filter((o) => wanted.has(o.hash));
-    } else {
-      opsToSend = localOps;
-    }
-    await this.sendOpsMessage(msg.peerId, opsToSend);
-  }
-  async handleOps(msg) {
-    if (msg.ops.length === 0) return;
-    let result;
-    if (this.branchPolicy.linear) {
-      const localOps = this.getLocalOps();
-      const localHashes = new Set(localOps.map((o) => o.hash));
-      const newOps = msg.ops.filter((o) => !localHashes.has(o.hash));
-      if (newOps.length > 0) {
-        result = await this.onOpsReceived(newOps) ?? void 0;
-      }
-    } else {
-      const reconciled = this.reconcileWith(msg.ops);
-      if (reconciled.uniqueToB.length > 0) {
-        result = await this.onOpsReceived(reconciled.uniqueToB) ?? void 0;
-      }
-    }
-    const rejections = result?.rejections ?? [];
-    if (rejections.length > 0) {
-      const byReason = /* @__PURE__ */ new Map();
-      for (const r of rejections) {
-        const entry = byReason.get(r.reason) ?? {
-          refs: [],
-          details: r.details
-        };
-        entry.refs.push(r.hash);
-        byReason.set(r.reason, entry);
-      }
-      for (const [reason, entry] of byReason) {
-        await this.transport.send(msg.peerId, {
-          version: PROTOCOL_VERSION,
-          type: "nack",
-          peerId: this.localPeerId,
-          refs: entry.refs,
-          reason,
-          details: entry.details
-        });
-      }
-    }
-    const rejectedSet = new Set(rejections.map((r) => r.hash));
-    const ackHashes = msg.ops.map((o) => o.hash).filter((h) => !rejectedSet.has(h));
-    if (ackHashes.length > 0) {
-      await this.transport.send(msg.peerId, {
-        version: PROTOCOL_VERSION,
-        type: "ack",
-        peerId: this.localPeerId,
-        integrated: ackHashes
-      });
-    }
-    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
-  }
-  handleAck(msg) {
-    for (const hash of msg.integrated) {
-      this.state.pendingAcks.delete(hash);
-    }
-    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
-  }
-  async handleNack(msg) {
-    for (const ref of msg.refs) {
-      this.state.pendingAcks.delete(ref);
-    }
-    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
-    if (this.onNackReceived) {
-      await this.onNackReceived(msg);
-    }
-  }
-};
-
-// src/sync/vcs-sync-peer.ts
-var TrellisVcsSyncPeer = class {
-  engine;
-  syncEngine;
-  integrationResults = [];
-  remoteNacks = [];
-  constructor(opts) {
-    this.engine = opts.engine;
-    this.syncEngine = new SyncEngine({
-      localPeerId: opts.peerId,
-      transport: opts.transport,
-      getLocalOps: () => this.engine.getOps(),
-      onOpsReceived: async (ops) => {
-        const result = await this.engine.integrateOps(ops);
-        this.integrationResults.push(result);
-        await opts.onIntegrate?.(result);
-        const rejections = result.rejected.map(
-          (r) => ({
-            hash: r.op.hash,
-            reason: r.reason,
-            details: r.message
-          })
-        );
-        return { rejections };
-      },
-      onNackReceived: async (nack) => {
-        const info = {
-          peerId: nack.peerId,
-          reason: nack.reason,
-          refs: nack.refs,
-          details: nack.details
-        };
-        this.remoteNacks.push(info);
-        await opts.onRemoteNack?.(nack);
-      },
-      branchPolicy: opts.branchPolicy
-    });
-  }
-  async pushTo(peerId) {
-    return this.captureSync(peerId, () => this.syncEngine.pushTo(peerId));
-  }
-  async pullFrom(peerId) {
-    return this.captureSync(peerId, () => this.syncEngine.pullAllFrom(peerId));
-  }
-  async syncWith(peerId) {
-    return this.captureSync(peerId, async () => {
-      await this.syncEngine.pushTo(peerId);
-      await this.syncEngine.pullAllFrom(peerId);
-    });
-  }
-  listPeers() {
-    return this.syncEngine.listPeers();
-  }
-  getSyncEngine() {
-    return this.syncEngine;
-  }
-  /**
-   * Cumulative nacks received from remote peers since construction.
-   * Useful for tests and for consumers that want to inspect the full history.
-   * Sync results returned by `pushTo`/`pullFrom`/`syncWith` already include
-   * the per-session slice in `remoteRejected`.
-   */
-  getRemoteNacks() {
-    return this.remoteNacks;
-  }
-  async captureSync(peerId, run) {
-    const beforeOpCount = this.engine.getOpCount();
-    const start = this.integrationResults.length;
-    const nackStart = this.remoteNacks.length;
-    await run();
-    const batches = this.integrationResults.slice(start);
-    const remoteRejected = this.remoteNacks.slice(nackStart);
-    const afterOpCount = this.engine.getOpCount();
-    return {
-      peerId,
-      beforeOpCount,
-      afterOpCount,
-      batches,
-      applied: batches.reduce((sum, batch) => sum + batch.applied, 0),
-      skipped: batches.reduce((sum, batch) => sum + batch.skipped, 0),
-      rejected: batches.reduce(
-        (sum, batch) => sum + batch.rejected.length,
-        0
-      ),
-      remoteRejected
-    };
-  }
-};
-
-// src/sync/partykit-transport.ts
-var PartyKitRoomTransport = class {
-  peerId;
-  room;
-  roomUrl;
-  WebSocketImpl;
-  ws = null;
-  messageHandler = null;
-  constructor(opts) {
-    this.peerId = opts.peerId;
-    this.roomUrl = opts.roomUrl;
-    this.room = {
-      id: opts.roomId ?? "room",
-      name: opts.roomName ?? opts.roomId ?? "room"
-    };
-    const WebSocketGlobal = globalThis.WebSocket;
-    const WebSocketImpl = opts.WebSocketImpl ?? WebSocketGlobal;
-    if (!WebSocketImpl) {
-      throw new Error(
-        "PartyKitRoomTransport requires WebSocket or opts.WebSocketImpl."
-      );
-    }
-    this.WebSocketImpl = WebSocketImpl;
-  }
-  async connect() {
-    if (this.ws?.readyState === 1) return;
-    await new Promise((resolve, reject) => {
-      const ws = new this.WebSocketImpl(this.roomUrl);
-      this.ws = ws;
-      ws.onopen = () => resolve();
-      ws.onerror = (event) => {
-        reject(new Error(`PartyKit room connection failed: ${String(event)}`));
-      };
-      ws.onmessage = async (event) => {
-        const message = this.parseMessage(event.data);
-        if (!message || !this.messageHandler) return;
-        await this.messageHandler(message);
-      };
-      ws.onclose = () => {
-        if (this.ws === ws) {
-          this.ws = null;
-        }
-      };
-    });
-  }
-  async send(peerId, message) {
-    if (peerId !== this.room.id) {
-      throw new Error(`PartyKitRoomTransport can only send to ${this.room.id}.`);
-    }
-    await this.connect();
-    this.ws.send(JSON.stringify(message));
-  }
-  onMessage(handler) {
-    this.messageHandler = handler;
-  }
-  peers() {
-    return [this.room];
-  }
-  close() {
-    this.ws?.close();
-    this.ws = null;
-  }
-  getPeerId() {
-    return this.peerId;
-  }
-  getRoomPeer() {
-    return { ...this.room };
-  }
-  parseMessage(data) {
-    try {
-      const raw = typeof data === "string" ? data : String(data);
-      const parsed = JSON.parse(raw);
-      return parsed && typeof parsed.type === "string" ? parsed : null;
-    } catch {
-      return null;
-    }
-  }
-};
-
-export {
-  PROTOCOL_VERSION,
-  MIN_SUPPORTED_VERSION,
-  MAX_SUPPORTED_VERSION,
-  SyncEngine,
-  TrellisVcsSyncPeer,
-  PartyKitRoomTransport
-};

package/dist/chunk-BRGYDO7D.js

@@ -1,223 +0,0 @@
-// src/schema/entity-projection.ts
-function entityRecordToPlain(entity) {
-  const obj = { id: entity.id, type: entity.type };
-  for (const f of entity.facts) {
-    if (f.a !== "type") obj[f.a] = f.v;
-  }
-  return obj;
-}
-function bindingEntityId(row) {
-  const id = row.id ?? row.e ?? row["?e"];
-  return typeof id === "string" && id.length > 0 ? id : null;
-}
-function isSparseBinding(row) {
-  const id = bindingEntityId(row);
-  if (!id) return false;
-  return typeof row.type !== "string";
-}
-function bindingToEntity(row) {
-  const id = bindingEntityId(row);
-  if (id && typeof row.type === "string") {
-    return { ...row, id, type: row.type };
-  }
-  if (id) return { id, type: String(row.type ?? ""), ...row };
-  return row;
-}
-function hydrateBindings(kernel, bindings) {
-  return bindings.map((row) => {
-    if (!isSparseBinding(row)) return bindingToEntity(row);
-    const id = bindingEntityId(row);
-    const entity = kernel.getEntity(id);
-    return entity ? entityRecordToPlain(entity) : bindingToEntity(row);
-  });
-}
-
-// src/schema/eql.ts
-function escapeValue(v) {
-  return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-var WHERE_OP_TO_EQL = {
-  eq: "=",
-  ne: "!=",
-  lt: "<",
-  lte: "<=",
-  gt: ">",
-  gte: ">=",
-  contains: "contains",
-  startsWith: "startsWith",
-  endsWith: "endsWith"
-};
-function isWhereFilter(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  return Object.keys(WHERE_OP_TO_EQL).some(
-    (op) => value[op] !== void 0
-  );
-}
-function formatEqlLiteral(value) {
-  if (typeof value === "string") return `"${escapeValue(value)}"`;
-  if (typeof value === "boolean") return value ? "true" : "false";
-  if (typeof value === "number" && Number.isFinite(value)) return String(value);
-  if (value === null || value === void 0) {
-    throw new Error("Cannot format null/undefined as an EQL literal");
-  }
-  return `"${escapeValue(String(value))}"`;
-}
-function whereCondition(attr, value) {
-  if (isWhereFilter(value)) {
-    const ops = Object.keys(WHERE_OP_TO_EQL).filter(
-      (op2) => value[op2] !== void 0
-    );
-    if (ops.length === 0) {
-      throw new Error(`Empty where filter for attribute "${attr}"`);
-    }
-    if (ops.length > 1) {
-      throw new Error(
-        `Where filter for "${attr}" must specify one operator, got: ${ops.join(", ")}`
-      );
-    }
-    const op = ops[0];
-    return `${attr} ${WHERE_OP_TO_EQL[op]} ${formatEqlLiteral(value[op])}`;
-  }
-  return `${attr} = ${formatEqlLiteral(value)}`;
-}
-function entitiesQuery(type, where) {
-  const conds = [`type = "${escapeValue(type)}"`];
-  for (const [k, v] of Object.entries(where ?? {})) {
-    if (v === void 0 || v === null) continue;
-    conds.push(whereCondition(k, v));
-  }
-  return `find ?e where ${conds.join(" and ")}`;
-}
-
-// src/schema/resolve.ts
-function isNestedResolveSpec(v) {
-  return typeof v === "object" && v !== null;
-}
-function relationTargetName(r) {
-  return typeof r.target === "string" ? r.target : r.target().type;
-}
-function relationTargetSchema(r, schemaLookup) {
-  if (typeof r.target !== "string") return r.target();
-  return schemaLookup?.(r.target) ?? null;
-}
-function inverseForeignKey(parent, relationName, child) {
-  for (const [key, r] of Object.entries(child.relations)) {
-    if (relationTargetName(r) === parent.type) return key;
-  }
-  return null;
-}
-async function loadByIds(client, ids, cache) {
-  const missing = ids.filter((id) => !cache.has(id));
-  if (missing.length === 0) return;
-  await Promise.all(
-    missing.map(async (id) => {
-      cache.set(id, await client.read(id));
-    })
-  );
-}
-async function resolveReverseMany(client, parent, relationName, parents, cache, schemaLookup) {
-  const rel = parent.relations[relationName];
-  if (!rel || rel.cardinality !== "many") return;
-  const childSchema = relationTargetSchema(rel, schemaLookup);
-  if (!childSchema) return;
-  const foreignKey = inverseForeignKey(parent, relationName, childSchema);
-  if (!foreignKey) return;
-  const parentIds = new Set(parents.map((p) => p.id));
-  const qr = await client.query(entitiesQuery(childSchema.type));
-  const childIds = qr.bindings.map((b) => bindingEntityId(b)).filter((id) => Boolean(id));
-  await loadByIds(client, childIds, cache);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const id of childIds) {
-    const child = cache.get(id);
-    if (!child) continue;
-    const fk = child[foreignKey];
-    if (typeof fk !== "string" || !parentIds.has(fk)) continue;
-    if (!grouped.has(fk)) grouped.set(fk, []);
-    grouped.get(fk).push(child);
-  }
-  for (const row of parents) {
-    row[relationName] = grouped.get(row.id) ?? [];
-  }
-}
-async function resolveForwardOne(client, parents, relationName, cache) {
-  const ids = parents.map((p) => p[relationName]).filter((v) => typeof v === "string" && v.length > 0);
-  await loadByIds(client, ids, cache);
-  for (const row of parents) {
-    const ref = row[relationName];
-    if (typeof ref !== "string") continue;
-    const loaded = cache.get(ref);
-    if (loaded) row[relationName] = loaded;
-  }
-}
-async function resolveRelations(client, schema, entities, spec, opts) {
-  if (entities.length === 0 || Object.keys(spec).length === 0) return entities;
-  const cache = /* @__PURE__ */ new Map();
-  const rows = opts?.copy === false ? entities : entities.map((e) => ({ ...e }));
-  for (const [name, enabled] of Object.entries(spec)) {
-    if (!enabled) continue;
-    const rel = schema.relations[name];
-    if (!rel) continue;
-    if (rel.cardinality === "many") {
-      await resolveReverseMany(
-        client,
-        schema,
-        name,
-        rows,
-        cache,
-        opts?.schemaLookup
-      );
-      if (isNestedResolveSpec(enabled)) {
-        const childSchema = relationTargetSchema(rel, opts?.schemaLookup);
-        if (childSchema) {
-          for (const row of rows) {
-            const kids = row[name];
-            if (kids?.length) {
-              await resolveRelations(client, childSchema, kids, enabled, {
-                copy: false,
-                schemaLookup: opts?.schemaLookup
-              });
-            }
-          }
-        }
-      }
-    } else if (isNestedResolveSpec(enabled)) {
-      await resolveForwardOne(client, rows, name, cache);
-      const childSchema = relationTargetSchema(rel, opts?.schemaLookup);
-      if (childSchema) {
-        const nested = [];
-        for (const row of rows) {
-          const loaded = row[name];
-          if (loaded && typeof loaded === "object" && "id" in loaded) {
-            nested.push(loaded);
-          }
-        }
-        if (nested.length) {
-          await resolveRelations(client, childSchema, nested, enabled, {
-            copy: false,
-            schemaLookup: opts?.schemaLookup
-          });
-        }
-      }
-    } else {
-      await resolveForwardOne(client, rows, name, cache);
-    }
-  }
-  return rows;
-}
-
-export {
-  entityRecordToPlain,
-  bindingEntityId,
-  isSparseBinding,
-  bindingToEntity,
-  hydrateBindings,
-  escapeValue,
-  isWhereFilter,
-  formatEqlLiteral,
-  whereCondition,
-  entitiesQuery,
-  inverseForeignKey,
-  resolveRelations
-};