@dxos/versioning 0.10.0

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,418 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Branch.ts
+var Branch_exports = {};
+__export(Branch_exports, {
+  Branch: () => Branch,
+  Status: () => BranchStatus,
+  create: () => createBranch,
+  discard: () => discardBranch,
+  find: () => findBranch,
+  label: () => branchLabel,
+  make: () => makeBranch,
+  merge: () => mergeBranch
+});
+
+// src/internal/types.ts
+import * as Schema from "effect/Schema";
+import { Key, Ref } from "@dxos/echo";
+import { Text } from "@dxos/schema";
+var Version = Schema.mutable(Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  target: Ref.Ref(Text.Text),
+  heads: Schema.mutable(Schema.Array(Schema.String)),
+  createdAt: Schema.String,
+  creator: Schema.optional(Schema.String),
+  message: Schema.optional(Schema.String)
+}));
+var BranchStatus = Schema.Literal("active", "merged", "archived");
+var Branch = Schema.mutable(Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  content: Ref.Ref(Text.Text),
+  parent: Ref.Ref(Text.Text),
+  anchor: Schema.mutable(Schema.Array(Schema.String)),
+  status: BranchStatus,
+  createdAt: Schema.String,
+  creator: Schema.optional(Schema.String),
+  mergedAt: Schema.optional(Schema.String)
+}));
+var History = Schema.mutable(Schema.Struct({
+  branches: Schema.mutable(Schema.Array(Branch)),
+  versions: Schema.mutable(Schema.Array(Version))
+}));
+var makeVersion = (props) => ({
+  id: Key.EntityId.random(),
+  createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+  ...props
+});
+var makeBranch = (props) => ({
+  id: Key.EntityId.random(),
+  status: "active",
+  createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+  ...props
+});
+
+// src/internal/model.ts
+import { Text as EchoText, Obj, Ref as Ref2 } from "@dxos/echo";
+import { checkoutVersion } from "@dxos/echo-client";
+import { invariant } from "@dxos/invariant";
+import { Text as Text2 } from "@dxos/schema";
+
+// src/diff.ts
+import { diffLines, diffWordsWithSpace } from "diff";
+var diffSpans = (before, after) => {
+  const spans = [];
+  let offset = 0;
+  for (const change of diffWordsWithSpace(before, after)) {
+    const kind = change.added ? "insert" : change.removed ? "delete" : "equal";
+    const length = kind === "delete" ? 0 : change.value.length;
+    spans.push({
+      kind,
+      from: offset,
+      to: offset + length,
+      text: change.value
+    });
+    offset += length;
+  }
+  return spans;
+};
+var diffStats = (spans) => spans.reduce((stats, span) => {
+  if (span.kind === "insert") {
+    stats.insertions += span.text.length;
+  } else if (span.kind === "delete") {
+    stats.deletions += span.text.length;
+  }
+  return stats;
+}, {
+  insertions: 0,
+  deletions: 0
+});
+var merge3 = ({ base, ours, theirs }) => {
+  if (ours === base) {
+    return {
+      text: theirs,
+      conflicts: 0
+    };
+  }
+  if (theirs === base || ours === theirs) {
+    return {
+      text: ours,
+      conflicts: 0
+    };
+  }
+  const baseLines = splitLines(base);
+  const oursHunks = lineHunks(baseLines, splitLines(ours));
+  const theirsHunks = lineHunks(baseLines, splitLines(theirs));
+  const out = [];
+  let conflicts = 0;
+  let baseIndex = 0;
+  let oursCursor = 0;
+  let theirsCursor = 0;
+  while (baseIndex < baseLines.length || oursCursor < oursHunks.length || theirsCursor < theirsHunks.length) {
+    const oursHunk = oursHunks[oursCursor];
+    const theirsHunk = theirsHunks[theirsCursor];
+    const nextOurs = oursHunk?.baseStart ?? Infinity;
+    const nextTheirs = theirsHunk?.baseStart ?? Infinity;
+    const next = Math.min(nextOurs, nextTheirs);
+    while (baseIndex < Math.min(next, baseLines.length)) {
+      out.push(baseLines[baseIndex]);
+      baseIndex += 1;
+    }
+    if (next === Infinity) {
+      break;
+    }
+    const oursActive = oursHunk !== void 0 && oursHunk.baseStart === next;
+    const theirsActive = theirsHunk !== void 0 && theirsHunk.baseStart === next;
+    const identical = oursActive && theirsActive && sameLines(oursHunk.lines, theirsHunk.lines) && oursHunk.baseLength === theirsHunk.baseLength;
+    const overlap = !identical && oursHunk !== void 0 && theirsHunk !== void 0 && (nextOurs === nextTheirs || oursActive && nextTheirs < hunkEnd(oursHunk) || theirsActive && nextOurs < hunkEnd(theirsHunk));
+    if (overlap) {
+      const oursRegion = [
+        oursHunk
+      ];
+      const theirsRegion = [
+        theirsHunk
+      ];
+      oursCursor += 1;
+      theirsCursor += 1;
+      let unionEnd = Math.max(hunkEnd(oursHunk), hunkEnd(theirsHunk));
+      let expanded = true;
+      while (expanded) {
+        expanded = false;
+        while (oursCursor < oursHunks.length && oursHunks[oursCursor].baseStart < unionEnd) {
+          const hunk = oursHunks[oursCursor];
+          oursRegion.push(hunk);
+          unionEnd = Math.max(unionEnd, hunkEnd(hunk));
+          oursCursor += 1;
+          expanded = true;
+        }
+        while (theirsCursor < theirsHunks.length && theirsHunks[theirsCursor].baseStart < unionEnd) {
+          const hunk = theirsHunks[theirsCursor];
+          theirsRegion.push(hunk);
+          unionEnd = Math.max(unionEnd, hunkEnd(hunk));
+          theirsCursor += 1;
+          expanded = true;
+        }
+      }
+      out.push("<<<<<<< branch", ...sideContent(baseLines, theirsRegion, next, unionEnd), "=======", ...sideContent(baseLines, oursRegion, next, unionEnd), ">>>>>>> current");
+      conflicts += 1;
+      baseIndex = unionEnd;
+    } else if (identical) {
+      out.push(...oursHunk.lines);
+      baseIndex = next + oursHunk.baseLength;
+      oursCursor += 1;
+      theirsCursor += 1;
+    } else if (oursActive) {
+      out.push(...oursHunk.lines);
+      baseIndex = next + oursHunk.baseLength;
+      oursCursor += 1;
+    } else if (theirsHunk !== void 0) {
+      out.push(...theirsHunk.lines);
+      baseIndex = next + theirsHunk.baseLength;
+      theirsCursor += 1;
+    }
+  }
+  return {
+    text: joinLines(out, [
+      base,
+      ours,
+      theirs
+    ]),
+    conflicts
+  };
+};
+var hunkEnd = (hunk) => hunk.baseStart + hunk.baseLength;
+var sideContent = (baseLines, hunks, unionStart, unionEnd) => {
+  const out = [];
+  let position = unionStart;
+  for (const hunk of hunks) {
+    out.push(...baseLines.slice(position, hunk.baseStart), ...hunk.lines);
+    position = Math.max(position, hunkEnd(hunk));
+  }
+  out.push(...baseLines.slice(position, unionEnd));
+  return out;
+};
+var lineHunks = (baseLines, sideLines) => {
+  const hunks = [];
+  let baseIndex = 0;
+  let pending;
+  for (const change of diffLines(joinForDiff(baseLines), joinForDiff(sideLines))) {
+    const lines = chunkLines(change.value);
+    if (change.added) {
+      pending = pending ?? {
+        baseStart: baseIndex,
+        baseLength: 0,
+        lines: []
+      };
+      pending.lines.push(...lines);
+    } else if (change.removed) {
+      pending = pending ?? {
+        baseStart: baseIndex,
+        baseLength: 0,
+        lines: []
+      };
+      pending.baseLength += lines.length;
+      baseIndex += lines.length;
+    } else {
+      if (pending) {
+        hunks.push(pending);
+        pending = void 0;
+      }
+      baseIndex += lines.length;
+    }
+  }
+  if (pending) {
+    hunks.push(pending);
+  }
+  return hunks;
+};
+var sameLines = (a, b) => a.length === b.length && a.every((line, index) => line === b[index]);
+var splitLines = (text) => text === "" ? [] : stripTrailingNewline(text).split("\n");
+var chunkLines = (value) => stripTrailingNewline(value).split("\n");
+var stripTrailingNewline = (text) => text.endsWith("\n") ? text.slice(0, -1) : text;
+var joinForDiff = (lines) => lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+var joinLines = (lines, inputs) => {
+  const text = lines.join("\n");
+  const nonEmpty = inputs.filter((input) => input.length > 0);
+  const trailing = nonEmpty.length > 0 && nonEmpty.every((input) => input.endsWith("\n"));
+  return trailing && text.length > 0 ? `${text}
+` : text;
+};
+
+// src/internal/model.ts
+var __dxlog_file = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/worktree-guidance-6d5eb0/packages/sdk/versioning/src/internal/model.ts";
+var ensureHistory = (doc) => {
+  if (!doc.history) {
+    Obj.update(doc, (doc2) => {
+      doc2.history = {
+        branches: [],
+        versions: []
+      };
+    });
+  }
+  const history = doc.history;
+  invariant(history, "history not initialized", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 20, S: void 0, A: ["history", "'history not initialized'"] });
+  return history;
+};
+var getHeads = (text) => {
+  const version = Obj.version(text);
+  invariant(version.versioned && version.automergeHeads, "text is not versioned (not persisted?)", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 25, S: void 0, A: ["version.versioned && version.automergeHeads", "'text is not versioned (not persisted?)'"] });
+  return [
+    ...version.automergeHeads
+  ];
+};
+var contentAt = (text, heads) => {
+  const snapshot = checkoutVersion(text, [
+    ...heads
+  ]);
+  if (snapshot && typeof snapshot === "object" && "content" in snapshot) {
+    const { content } = snapshot;
+    return typeof content === "string" ? content : "";
+  }
+  return "";
+};
+var createCheckpoint = (doc, props) => {
+  const text = props.target;
+  const version = makeVersion({
+    name: props.name,
+    target: Ref2.make(text),
+    heads: getHeads(text),
+    ...props.message !== void 0 && {
+      message: props.message
+    },
+    ...props.creator !== void 0 && {
+      creator: props.creator
+    }
+  });
+  const history = ensureHistory(doc);
+  Obj.update(doc, () => {
+    history.versions.push(version);
+  });
+  const stored = history.versions.find(({ id }) => id === version.id);
+  invariant(stored, "checkpoint not stored", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 63, S: void 0, A: ["stored", "'checkpoint not stored'"] });
+  return stored;
+};
+var versionLabel = (version) => version.name || new Date(version.createdAt).toLocaleString();
+var branchLabel = (branch) => branch.name || new Date(branch.createdAt).toLocaleString();
+var findBranch = (doc, text) => doc.history?.branches.find((branch) => branch.content.target?.id === text.id);
+var createBranch = (doc, props) => {
+  const parent = props.parent;
+  const anchor = props.heads ? [
+    ...props.heads
+  ] : getHeads(parent);
+  const baseContent = contentAt(parent, anchor);
+  const branchText = Text2.make({
+    content: baseContent
+  });
+  const db = Obj.getDatabase(doc);
+  invariant(db, "document not in a database", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 83, S: void 0, A: ["db", "'document not in a database'"] });
+  db.add(branchText);
+  Obj.setParent(branchText, doc);
+  const branch = makeBranch({
+    name: props.name,
+    content: Ref2.make(branchText),
+    parent: Ref2.make(parent),
+    anchor,
+    ...props.creator !== void 0 && {
+      creator: props.creator
+    }
+  });
+  const history = ensureHistory(doc);
+  Obj.update(doc, () => {
+    history.branches.push(branch);
+  });
+  if (!history.versions.some((version) => sameHeads(version.heads, anchor))) {
+    const version = makeVersion({
+      name: `fork: ${branchLabel(branch)}`,
+      target: Ref2.make(parent),
+      heads: anchor
+    });
+    Obj.update(doc, () => {
+      history.versions.push(version);
+    });
+  }
+  const stored = history.branches.find(({ id }) => id === branch.id);
+  invariant(stored, "branch not stored", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 112, S: void 0, A: ["stored", "'branch not stored'"] });
+  return stored;
+};
+var restore = (doc, version) => {
+  const text = version.target.target;
+  invariant(text, "checkpoint target not loaded", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 117, S: void 0, A: ["text", "'checkpoint target not loaded'"] });
+  const historical = contentAt(text, version.heads);
+  Obj.update(text, () => {
+    EchoText.update(text, "content", historical);
+  });
+};
+var mergeBranch = (doc, branch) => {
+  const stored = resolveBranch(doc, branch);
+  invariant(stored.status === "active", "branch is not active", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 129, S: void 0, A: ["stored.status === 'active'", "'branch is not active'"] });
+  const parent = stored.parent.target;
+  const branchText = stored.content.target;
+  invariant(parent && branchText, "branch refs not loaded", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 132, S: void 0, A: ["parent && branchText", "'branch refs not loaded'"] });
+  const base = contentAt(parent, stored.anchor);
+  const { text, conflicts } = merge3({
+    base,
+    ours: parent.content,
+    theirs: branchText.content
+  });
+  Obj.update(parent, () => {
+    EchoText.update(parent, "content", text);
+  });
+  Obj.update(doc, () => {
+    stored.status = "merged";
+    stored.mergedAt = (/* @__PURE__ */ new Date()).toISOString();
+  });
+  createCheckpoint(doc, {
+    name: `merge: ${branchLabel(stored)}`,
+    target: parent
+  });
+  return {
+    conflicts
+  };
+};
+var discardBranch = (doc, branch) => {
+  const stored = resolveBranch(doc, branch);
+  Obj.update(doc, () => {
+    stored.status = "archived";
+  });
+};
+var resolveBranch = (doc, branch) => {
+  const stored = doc.history?.branches.find(({ id }) => id === branch.id);
+  invariant(stored, `branch not found: ${branch.id}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 162, S: void 0, A: ["stored", "`branch not found: ${branch.id}`"] });
+  return stored;
+};
+var sameHeads = (a, b) => a.length === b.length && a.every((head) => b.includes(head));
+
+// src/History.ts
+var History_exports = {};
+__export(History_exports, {
+  History: () => History,
+  ensure: () => ensureHistory
+});
+
+// src/Version.ts
+var Version_exports = {};
+__export(Version_exports, {
+  Version: () => Version,
+  contentAt: () => contentAt,
+  create: () => createCheckpoint,
+  label: () => versionLabel,
+  make: () => makeVersion,
+  restore: () => restore
+});
+export {
+  Branch_exports as Branch,
+  History_exports as History,
+  Version_exports as Version,
+  diffSpans,
+  diffStats,
+  merge3
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Branch.ts", "../../../src/internal/types.ts", "../../../src/internal/model.ts", "../../../src/diff.ts", "../../../src/History.ts", "../../../src/Version.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nexport {\n  Branch,\n  type MakeBranchProps as MakeProps,\n  BranchStatus as Status,\n  makeBranch as make,\n} from './internal/types';\nexport {\n  type CreateBranchProps as CreateProps,\n  type MergeResult,\n  createBranch as create,\n  discardBranch as discard,\n  findBranch as find,\n  branchLabel as label,\n  mergeBranch as merge,\n} from './internal/model';\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Key, Ref } from '@dxos/echo';\nimport { Text } from '@dxos/schema';\n\n/**\n * Named checkpoint: a pointer to the automerge heads of a Text's backing document.\n * Heads are content-addressed change hashes, stable across peers, so a checkpoint is zero-copy.\n * Generic over any object holding a `history` field (see model.ts).\n */\nexport const Version = Schema.mutable(\n  Schema.Struct({\n    id: Schema.String,\n    name: Schema.String,\n    target: Ref.Ref(Text.Text),\n    heads: Schema.mutable(Schema.Array(Schema.String)),\n    createdAt: Schema.String,\n    creator: Schema.optional(Schema.String),\n    message: Schema.optional(Schema.String),\n  }),\n);\nexport interface Version extends Schema.Schema.Type<typeof Version> {}\n\nexport const BranchStatus = Schema.Literal('active', 'merged', 'archived');\nexport type BranchStatus = Schema.Schema.Type<typeof BranchStatus>;\n\n/**\n * A draft Text forked from a parent Text at a specific revision (anchor heads).\n * The branch tree is formed by `parent` references; the root is Document.content.\n */\nexport const Branch = Schema.mutable(\n  Schema.Struct({\n    id: Schema.String,\n    name: Schema.String,\n    content: Ref.Ref(Text.Text),\n    parent: Ref.Ref(Text.Text),\n    anchor: Schema.mutable(Schema.Array(Schema.String)),\n    status: BranchStatus,\n    createdAt: Schema.String,\n    creator: Schema.optional(Schema.String),\n    mergedAt: Schema.optional(Schema.String),\n  }),\n);\nexport interface Branch extends Schema.Schema.Type<typeof Branch> {}\n\nexport const History = Schema.mutable(\n  Schema.Struct({\n    branches: Schema.mutable(Schema.Array(Branch)),\n    versions: Schema.mutable(Schema.Array(Version)),\n  }),\n);\nexport interface History extends Schema.Schema.Type<typeof History> {}\n\nexport type MakeVersionProps = Pick<Version, 'target' | 'heads' | 'name'> &\n  Partial<Pick<Version, 'creator' | 'message'>>;\n\n/** Constructs a Version checkpoint record with a generated id and creation timestamp. */\nexport const makeVersion = (props: MakeVersionProps): Version => ({\n  id: Key.EntityId.random(),\n  createdAt: new Date().toISOString(),\n  ...props,\n});\n\nexport type MakeBranchProps = Pick<Branch, 'content' | 'parent' | 'anchor' | 'name'> & Partial<Pick<Branch, 'creator'>>;\n\n/** Constructs an active Branch record with a generated id and creation timestamp. */\nexport const makeBranch = (props: MakeBranchProps): Branch => ({\n  id: Key.EntityId.random(),\n  status: 'active',\n  createdAt: new Date().toISOString(),\n  ...props,\n});\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { Text as EchoText, Obj, Ref } from '@dxos/echo';\nimport { checkoutVersion } from '@dxos/echo-client';\nimport { invariant } from '@dxos/invariant';\nimport { Text } from '@dxos/schema';\n\nimport { merge3 } from '../diff';\nimport * as Versioning from './types';\n\n/** Any ECHO object that carries a versioning history (e.g. a markdown document). */\nexport type VersionedObject = Obj.Unknown & { history?: Versioning.History | undefined };\n\n/** Initializes the history struct on first use so existing documents need no migration. */\nexport const ensureHistory = (doc: VersionedObject): Versioning.History => {\n  if (!doc.history) {\n    Obj.update(doc, (doc) => {\n      doc.history = { branches: [], versions: [] };\n    });\n  }\n  const history = doc.history;\n  invariant(history, 'history not initialized');\n  return history;\n};\n\nconst getHeads = (text: Text.Text): string[] => {\n  const version = Obj.version(text);\n  invariant(version.versioned && version.automergeHeads, 'text is not versioned (not persisted?)');\n  return [...version.automergeHeads];\n};\n\n/** @returns The Text content at the given automerge heads (read-only time travel). */\nexport const contentAt = (text: Text.Text, heads: readonly string[]): string => {\n  // `checkoutVersion` returns `unknown` (raw historical data) — narrow via runtime checks.\n  const snapshot = checkoutVersion(text, [...heads]);\n  if (snapshot && typeof snapshot === 'object' && 'content' in snapshot) {\n    const { content } = snapshot;\n    return typeof content === 'string' ? content : '';\n  }\n  return '';\n};\n\nexport type CreateCheckpointProps = { target: Text.Text; name: string; message?: string; creator?: string };\n\n/**\n * Records a named checkpoint of the target Text's current automerge heads and appends it to\n * the object's history. Zero-copy: only the heads are stored.\n */\nexport const createCheckpoint = (doc: VersionedObject, props: CreateCheckpointProps): Versioning.Version => {\n  const text = props.target;\n  const version = Versioning.makeVersion({\n    name: props.name,\n    target: Ref.make(text),\n    heads: getHeads(text),\n    ...(props.message !== undefined && { message: props.message }),\n    ...(props.creator !== undefined && { creator: props.creator }),\n  });\n  const history = ensureHistory(doc);\n  Obj.update(doc, () => {\n    history.versions.push(version);\n  });\n\n  // Return the stored record (the pushed plain object is detached from the database).\n  const stored = history.versions.find(({ id }) => id === version.id);\n  invariant(stored, 'checkpoint not stored');\n  return stored;\n};\n\n/** Display label for a checkpoint: its name, or the formatted creation time when unnamed. */\nexport const versionLabel = (version: Versioning.Version): string =>\n  version.name || new Date(version.createdAt).toLocaleString();\n\n/** Display label for a branch: its name, or the formatted creation time when unnamed. */\nexport const branchLabel = (branch: Versioning.Branch): string =>\n  branch.name || new Date(branch.createdAt).toLocaleString();\n\n/** Find the branch record owning a given Text (undefined for the root). */\nexport const findBranch = (doc: VersionedObject, text: Text.Text): Versioning.Branch | undefined =>\n  doc.history?.branches.find((branch) => branch.content.target?.id === text.id);\n\nexport type CreateBranchProps = {\n  name: string;\n  parent: Text.Text;\n  heads?: readonly string[];\n  creator?: string;\n};\n\n/**\n * Forks a draft branch: a new Text seeded with the parent's content at the anchor heads\n * (defaults to the parent's current heads), recorded in the object's history. The anchor is\n * auto-checkpointed so the fork point stays addressable in the timeline.\n */\nexport const createBranch = (doc: VersionedObject, props: CreateBranchProps): Versioning.Branch => {\n  const parent = props.parent;\n  const anchor = props.heads ? [...props.heads] : getHeads(parent);\n  const baseContent = contentAt(parent, anchor);\n\n  const branchText = Text.make({ content: baseContent });\n  const db = Obj.getDatabase(doc);\n  invariant(db, 'document not in a database');\n  db.add(branchText);\n  Obj.setParent(branchText, doc);\n\n  const branch = Versioning.makeBranch({\n    name: props.name,\n    content: Ref.make(branchText),\n    parent: Ref.make(parent),\n    anchor,\n    ...(props.creator !== undefined && { creator: props.creator }),\n  });\n\n  const history = ensureHistory(doc);\n  Obj.update(doc, () => {\n    history.branches.push(branch);\n  });\n  // The anchor must stay addressable by name in the timeline.\n  if (!history.versions.some((version) => sameHeads(version.heads, anchor))) {\n    const version = Versioning.makeVersion({\n      name: `fork: ${branchLabel(branch)}`,\n      target: Ref.make(parent),\n      heads: anchor,\n    });\n    Obj.update(doc, () => {\n      history.versions.push(version);\n    });\n  }\n\n  // Return the stored record (the pushed plain object is detached from the database).\n  const stored = history.branches.find(({ id }) => id === branch.id);\n  invariant(stored, 'branch not stored');\n  return stored;\n};\n\n/** Applies the checkpoint's content to the tip as a new forward edit — history is never rewritten. */\nexport const restore = (doc: VersionedObject, version: Versioning.Version): void => {\n  const text = version.target.target;\n  invariant(text, 'checkpoint target not loaded');\n  const historical = contentAt(text, version.heads);\n  Obj.update(text, () => {\n    EchoText.update(text, 'content', historical);\n  });\n};\n\nexport type MergeResult = { conflicts: number };\n\n/**\n * 3-way merge: base = parent@anchor, ours = parent tip, theirs = branch tip.\n * Conflicting hunks are left in the document with git-style markers for manual cleanup.\n */\nexport const mergeBranch = (doc: VersionedObject, branch: Versioning.Branch): MergeResult => {\n  // Callers may hold a detached copy of the record — mutate the stored one.\n  const stored = resolveBranch(doc, branch);\n  invariant(stored.status === 'active', 'branch is not active');\n  const parent = stored.parent.target;\n  const branchText = stored.content.target;\n  invariant(parent && branchText, 'branch refs not loaded');\n\n  const base = contentAt(parent, stored.anchor);\n  const { text, conflicts } = merge3({ base, ours: parent.content, theirs: branchText.content });\n  Obj.update(parent, () => {\n    EchoText.update(parent, 'content', text);\n  });\n  Obj.update(doc, () => {\n    stored.status = 'merged';\n    stored.mergedAt = new Date().toISOString();\n  });\n\n  createCheckpoint(doc, { name: `merge: ${branchLabel(stored)}`, target: parent });\n  return { conflicts };\n};\n\n/** Archives the branch; its Text is retained for recovery. */\nexport const discardBranch = (doc: VersionedObject, branch: Versioning.Branch): void => {\n  const stored = resolveBranch(doc, branch);\n  Obj.update(doc, () => {\n    stored.status = 'archived';\n  });\n};\n\nconst resolveBranch = (doc: VersionedObject, branch: Versioning.Branch): Versioning.Branch => {\n  const stored = doc.history?.branches.find(({ id }) => id === branch.id);\n  invariant(stored, `branch not found: ${branch.id}`);\n  return stored;\n};\n\nconst sameHeads = (a: readonly string[], b: readonly string[]) =>\n  a.length === b.length && a.every((head) => b.includes(head));\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { diffLines, diffWordsWithSpace } from 'diff';\n\n/**\n * Shared diff unit consumed by all diff renderings (inline, side-by-side, gutter).\n * Offsets index into the AFTER text; deletions are zero-width and carry the offset where\n * the removed text used to be, so widgets can render the removed content in place.\n */\nexport type DiffSpan = {\n  kind: 'equal' | 'insert' | 'delete';\n  from: number;\n  to: number;\n  text: string;\n};\n\n/** Computes word-level {@link DiffSpan}s between two texts, offset into the after text. */\nexport const diffSpans = (before: string, after: string): DiffSpan[] => {\n  const spans: DiffSpan[] = [];\n  let offset = 0;\n  for (const change of diffWordsWithSpace(before, after)) {\n    const kind = change.added ? 'insert' : change.removed ? 'delete' : 'equal';\n    const length = kind === 'delete' ? 0 : change.value.length;\n    spans.push({ kind, from: offset, to: offset + length, text: change.value });\n    offset += length;\n  }\n  return spans;\n};\n\nexport type DiffStats = { insertions: number; deletions: number };\n\n/** Character counts, used for the `+N −M` branch summaries. */\nexport const diffStats = (spans: DiffSpan[]): DiffStats =>\n  spans.reduce(\n    (stats, span) => {\n      if (span.kind === 'insert') {\n        stats.insertions += span.text.length;\n      } else if (span.kind === 'delete') {\n        stats.deletions += span.text.length;\n      }\n      return stats;\n    },\n    { insertions: 0, deletions: 0 },\n  );\n\nexport type Merge3Props = { base: string; ours: string; theirs: string };\nexport type Merge3Result = { text: string; conflicts: number };\n\n/**\n * Line-based 3-way merge. Non-overlapping hunks apply automatically; overlapping hunks\n * produce git-style conflict markers with the branch (theirs) side first, since the merge\n * flow is review-then-accept and the branch content is what was just reviewed.\n */\nexport const merge3 = ({ base, ours, theirs }: Merge3Props): Merge3Result => {\n  if (ours === base) {\n    return { text: theirs, conflicts: 0 };\n  }\n  if (theirs === base || ours === theirs) {\n    return { text: ours, conflicts: 0 };\n  }\n\n  const baseLines = splitLines(base);\n  const oursHunks = lineHunks(baseLines, splitLines(ours));\n  const theirsHunks = lineHunks(baseLines, splitLines(theirs));\n\n  const out: string[] = [];\n  let conflicts = 0;\n  let baseIndex = 0;\n  let oursCursor = 0;\n  let theirsCursor = 0;\n\n  while (baseIndex < baseLines.length || oursCursor < oursHunks.length || theirsCursor < theirsHunks.length) {\n    const oursHunk = oursHunks[oursCursor];\n    const theirsHunk = theirsHunks[theirsCursor];\n    const nextOurs = oursHunk?.baseStart ?? Infinity;\n    const nextTheirs = theirsHunk?.baseStart ?? Infinity;\n    const next = Math.min(nextOurs, nextTheirs);\n\n    // Copy unchanged base lines up to the next hunk.\n    while (baseIndex < Math.min(next, baseLines.length)) {\n      out.push(baseLines[baseIndex]);\n      baseIndex += 1;\n    }\n    if (next === Infinity) {\n      break;\n    }\n\n    const oursActive = oursHunk !== undefined && oursHunk.baseStart === next;\n    const theirsActive = theirsHunk !== undefined && theirsHunk.baseStart === next;\n    const identical =\n      oursActive &&\n      theirsActive &&\n      sameLines(oursHunk.lines, theirsHunk.lines) &&\n      oursHunk.baseLength === theirsHunk.baseLength;\n    // Hunks conflict when their consumed base intervals overlap — same start, or a staggered\n    // hunk beginning inside the interval the active hunk consumes (e.g. [0,2) vs [1,2)).\n    const overlap =\n      !identical &&\n      oursHunk !== undefined &&\n      theirsHunk !== undefined &&\n      (nextOurs === nextTheirs ||\n        (oursActive && nextTheirs < hunkEnd(oursHunk)) ||\n        (theirsActive && nextOurs < hunkEnd(theirsHunk)));\n\n    if (overlap) {\n      // The conflict region is the connected union of every intersecting hunk on both sides —\n      // a broad hunk can overlap several smaller ones, all of which must be consumed together.\n      const oursRegion = [oursHunk];\n      const theirsRegion = [theirsHunk];\n      oursCursor += 1;\n      theirsCursor += 1;\n      let unionEnd = Math.max(hunkEnd(oursHunk), hunkEnd(theirsHunk));\n      let expanded = true;\n      while (expanded) {\n        expanded = false;\n        while (oursCursor < oursHunks.length && oursHunks[oursCursor].baseStart < unionEnd) {\n          const hunk = oursHunks[oursCursor];\n          oursRegion.push(hunk);\n          unionEnd = Math.max(unionEnd, hunkEnd(hunk));\n          oursCursor += 1;\n          expanded = true;\n        }\n        while (theirsCursor < theirsHunks.length && theirsHunks[theirsCursor].baseStart < unionEnd) {\n          const hunk = theirsHunks[theirsCursor];\n          theirsRegion.push(hunk);\n          unionEnd = Math.max(unionEnd, hunkEnd(hunk));\n          theirsCursor += 1;\n          expanded = true;\n        }\n      }\n\n      out.push(\n        '<<<<<<< branch',\n        ...sideContent(baseLines, theirsRegion, next, unionEnd),\n        '=======',\n        ...sideContent(baseLines, oursRegion, next, unionEnd),\n        '>>>>>>> current',\n      );\n      conflicts += 1;\n      baseIndex = unionEnd;\n    } else if (identical) {\n      out.push(...oursHunk.lines);\n      baseIndex = next + oursHunk.baseLength;\n      oursCursor += 1;\n      theirsCursor += 1;\n    } else if (oursActive) {\n      out.push(...oursHunk.lines);\n      baseIndex = next + oursHunk.baseLength;\n      oursCursor += 1;\n    } else if (theirsHunk !== undefined) {\n      out.push(...theirsHunk.lines);\n      baseIndex = next + theirsHunk.baseLength;\n      theirsCursor += 1;\n    }\n  }\n\n  return { text: joinLines(out, [base, ours, theirs]), conflicts };\n};\n\ntype Hunk = { baseStart: number; baseLength: number; lines: string[] };\n\nconst hunkEnd = (hunk: Hunk) => hunk.baseStart + hunk.baseLength;\n\n/** One side's content for a conflict region: its hunks plus the union's base lines they leave unchanged. */\nconst sideContent = (baseLines: string[], hunks: Hunk[], unionStart: number, unionEnd: number): string[] => {\n  const out: string[] = [];\n  let position = unionStart;\n  for (const hunk of hunks) {\n    out.push(...baseLines.slice(position, hunk.baseStart), ...hunk.lines);\n    position = Math.max(position, hunkEnd(hunk));\n  }\n  out.push(...baseLines.slice(position, unionEnd));\n  return out;\n};\n\n/** Convert jsdiff line changes into base-anchored replacement hunks. */\nconst lineHunks = (baseLines: string[], sideLines: string[]): Hunk[] => {\n  const hunks: Hunk[] = [];\n  let baseIndex = 0;\n  let pending: Hunk | undefined;\n  for (const change of diffLines(joinForDiff(baseLines), joinForDiff(sideLines))) {\n    const lines = chunkLines(change.value);\n    if (change.added) {\n      pending = pending ?? { baseStart: baseIndex, baseLength: 0, lines: [] };\n      pending.lines.push(...lines);\n    } else if (change.removed) {\n      pending = pending ?? { baseStart: baseIndex, baseLength: 0, lines: [] };\n      pending.baseLength += lines.length;\n      baseIndex += lines.length;\n    } else {\n      if (pending) {\n        hunks.push(pending);\n        pending = undefined;\n      }\n      baseIndex += lines.length;\n    }\n  }\n  if (pending) {\n    hunks.push(pending);\n  }\n  return hunks;\n};\n\nconst sameLines = (a: string[], b: string[]) => a.length === b.length && a.every((line, index) => line === b[index]);\n\nconst splitLines = (text: string): string[] => (text === '' ? [] : stripTrailingNewline(text).split('\\n'));\n\n// Unlike whole-document splitting, a diff chunk is never empty — a chunk of '\\n' is one blank\n// line (jsdiff attaches the terminator to its line), so no empty-string special case applies.\nconst chunkLines = (value: string): string[] => stripTrailingNewline(value).split('\\n');\n\nconst stripTrailingNewline = (text: string) => (text.endsWith('\\n') ? text.slice(0, -1) : text);\n\n// diffLines needs a trailing newline so the last line compares as a whole line.\nconst joinForDiff = (lines: string[]) => (lines.length === 0 ? '' : `${lines.join('\\n')}\\n`);\n\nconst joinLines = (lines: string[], inputs: string[]) => {\n  const text = lines.join('\\n');\n  // Preserve a trailing newline when every non-empty input has one.\n  const nonEmpty = inputs.filter((input) => input.length > 0);\n  const trailing = nonEmpty.length > 0 && nonEmpty.every((input) => input.endsWith('\\n'));\n  return trailing && text.length > 0 ? `${text}\\n` : text;\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nexport { History } from './internal/types';\nexport { type VersionedObject, ensureHistory as ensure } from './internal/model';\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nexport { type MakeVersionProps as MakeProps, Version, makeVersion as make } from './internal/types';\nexport {\n  type CreateCheckpointProps as CreateProps,\n  contentAt,\n  createCheckpoint as create,\n  versionLabel as label,\n  restore,\n} from './internal/model';\n"],
+  "mappings": "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",
+  "names": ["Schema", "Key", "Ref", "Text", "Version", "mutable", "Struct", "id", "String", "name", "target", "heads", "Array", "createdAt", "creator", "optional", "message", "BranchStatus", "Literal", "Branch", "content", "parent", "anchor", "status", "mergedAt", "History", "branches", "versions", "makeVersion", "props", "EntityId", "random", "Date", "toISOString", "makeBranch", "Text", "EchoText", "Obj", "Ref", "checkoutVersion", "invariant", "diffLines", "diffWordsWithSpace", "diffSpans", "before", "after", "spans", "offset", "change", "kind", "added", "removed", "length", "value", "push", "from", "to", "text", "diffStats", "reduce", "stats", "span", "insertions", "deletions", "merge3", "base", "ours", "theirs", "conflicts", "baseLines", "splitLines", "oursHunks", "lineHunks", "theirsHunks", "out", "baseIndex", "oursCursor", "theirsCursor", "oursHunk", "theirsHunk", "nextOurs", "baseStart", "Infinity", "nextTheirs", "next", "Math", "min", "oursActive", "undefined", "theirsActive", "identical", "sameLines", "lines", "baseLength", "overlap", "hunkEnd", "oursRegion", "theirsRegion", "unionEnd", "max", "expanded", "hunk", "sideContent", "joinLines", "hunks", "unionStart", "position", "slice", "sideLines", "pending", "joinForDiff", "chunkLines", "a", "b", "every", "line", "index", "stripTrailingNewline", "split", "endsWith", "join", "inputs", "nonEmpty", "filter", "input", "trailing", "doc", "history", "branches", "versions", "invariant", "getHeads", "version", "versioned", "automergeHeads", "snapshot", "content", "makeVersion", "name", "props", "target", "text", "heads", "message", "undefined", "creator", "Obj", "stored", "findBranch", "find", "branch", "id", "anchor", "parent", "baseContent", "branchText", "Text", "db", "setParent", "Versioning", "make", "branchLabel", "Ref", "update", "historical", "contentAt", "EchoText", "resolveBranch", "base", "conflicts", "merge3", "ours", "theirs", "mergedAt", "createCheckpoint", "status", "sameHeads"]
+}

package/dist/lib/node-esm/meta.json

@@ -0,0 +1 @@
+{"inputs":{"src/internal/types.ts":{"bytes":7963,"imports":[{"path":"effect/Schema","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"@dxos/schema","kind":"import-statement","external":true}],"format":"esm"},"src/diff.ts":{"bytes":27656,"imports":[{"path":"diff","kind":"import-statement","external":true}],"format":"esm"},"src/internal/model.ts":{"bytes":24412,"imports":[{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"@dxos/echo-client","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/schema","kind":"import-statement","external":true},{"path":"src/diff.ts","kind":"import-statement","original":"../diff"},{"path":"src/internal/types.ts","kind":"import-statement","original":"./types"}],"format":"esm"},"src/Branch.ts":{"bytes":1548,"imports":[{"path":"src/internal/types.ts","kind":"import-statement","original":"./internal/types"},{"path":"src/internal/model.ts","kind":"import-statement","original":"./internal/model"}],"format":"esm"},"src/History.ts":{"bytes":776,"imports":[{"path":"src/internal/types.ts","kind":"import-statement","original":"./internal/types"},{"path":"src/internal/model.ts","kind":"import-statement","original":"./internal/model"}],"format":"esm"},"src/Version.ts":{"bytes":1203,"imports":[{"path":"src/internal/types.ts","kind":"import-statement","original":"./internal/types"},{"path":"src/internal/model.ts","kind":"import-statement","original":"./internal/model"}],"format":"esm"},"src/index.ts":{"bytes":796,"imports":[{"path":"src/Branch.ts","kind":"import-statement","original":"./Branch"},{"path":"src/History.ts","kind":"import-statement","original":"./History"},{"path":"src/Version.ts","kind":"import-statement","original":"./Version"},{"path":"src/diff.ts","kind":"import-statement","original":"./diff"}],"format":"esm"}},"outputs":{"dist/lib/node-esm/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":31192},"dist/lib/node-esm/index.mjs":{"imports":[{"path":"effect/Schema","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"@dxos/schema","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"@dxos/echo-client","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/schema","kind":"import-statement","external":true},{"path":"diff","kind":"import-statement","external":true}],"exports":["Branch","History","Version","diffSpans","diffStats","merge3"],"entryPoint":"src/index.ts","inputs":{"src/Branch.ts":{"bytesInOutput":279},"src/internal/types.ts":{"bytesInOutput":1257},"src/internal/model.ts":{"bytesInOutput":5653},"src/diff.ts":{"bytesInOutput":5944},"src/index.ts":{"bytesInOutput":0},"src/History.ts":{"bytesInOutput":114},"src/Version.ts":{"bytesInOutput":229}},"bytes":14055}}}

package/dist/types/src/Branch.d.ts

@@ -0,0 +1,3 @@
+export { Branch, type MakeBranchProps as MakeProps, BranchStatus as Status, makeBranch as make, } from './internal/types';
+export { type CreateBranchProps as CreateProps, type MergeResult, createBranch as create, discardBranch as discard, findBranch as find, branchLabel as label, mergeBranch as merge, } from './internal/model';
+//# sourceMappingURL=Branch.d.ts.map

package/dist/types/src/Branch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Branch.d.ts","sourceRoot":"","sources":["../../../src/Branch.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,MAAM,EACN,KAAK,eAAe,IAAI,SAAS,EACjC,YAAY,IAAI,MAAM,EACtB,UAAU,IAAI,IAAI,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,iBAAiB,IAAI,WAAW,EACrC,KAAK,WAAW,EAChB,YAAY,IAAI,MAAM,EACtB,aAAa,IAAI,OAAO,EACxB,UAAU,IAAI,IAAI,EAClB,WAAW,IAAI,KAAK,EACpB,WAAW,IAAI,KAAK,GACrB,MAAM,kBAAkB,CAAC"}

package/dist/types/src/History.d.ts

@@ -0,0 +1,3 @@
+export { History } from './internal/types';
+export { type VersionedObject, ensureHistory as ensure } from './internal/model';
+//# sourceMappingURL=History.d.ts.map

package/dist/types/src/History.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"History.d.ts","sourceRoot":"","sources":["../../../src/History.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,KAAK,eAAe,EAAE,aAAa,IAAI,MAAM,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/types/src/Version.d.ts

@@ -0,0 +1,3 @@
+export { type MakeVersionProps as MakeProps, Version, makeVersion as make } from './internal/types';
+export { type CreateCheckpointProps as CreateProps, contentAt, createCheckpoint as create, versionLabel as label, restore, } from './internal/model';
+//# sourceMappingURL=Version.d.ts.map

package/dist/types/src/Version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Version.d.ts","sourceRoot":"","sources":["../../../src/Version.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,gBAAgB,IAAI,SAAS,EAAE,OAAO,EAAE,WAAW,IAAI,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACpG,OAAO,EACL,KAAK,qBAAqB,IAAI,WAAW,EACzC,SAAS,EACT,gBAAgB,IAAI,MAAM,EAC1B,YAAY,IAAI,KAAK,EACrB,OAAO,GACR,MAAM,kBAAkB,CAAC"}

package/dist/types/src/diff.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared diff unit consumed by all diff renderings (inline, side-by-side, gutter).
+ * Offsets index into the AFTER text; deletions are zero-width and carry the offset where
+ * the removed text used to be, so widgets can render the removed content in place.
+ */
+export type DiffSpan = {
+    kind: 'equal' | 'insert' | 'delete';
+    from: number;
+    to: number;
+    text: string;
+};
+/** Computes word-level {@link DiffSpan}s between two texts, offset into the after text. */
+export declare const diffSpans: (before: string, after: string) => DiffSpan[];
+export type DiffStats = {
+    insertions: number;
+    deletions: number;
+};
+/** Character counts, used for the `+N −M` branch summaries. */
+export declare const diffStats: (spans: DiffSpan[]) => DiffStats;
+export type Merge3Props = {
+    base: string;
+    ours: string;
+    theirs: string;
+};
+export type Merge3Result = {
+    text: string;
+    conflicts: number;
+};
+/**
+ * Line-based 3-way merge. Non-overlapping hunks apply automatically; overlapping hunks
+ * produce git-style conflict markers with the branch (theirs) side first, since the merge
+ * flow is review-then-accept and the branch content is what was just reviewed.
+ */
+export declare const merge3: ({ base, ours, theirs }: Merge3Props) => Merge3Result;
+//# sourceMappingURL=diff.d.ts.map

package/dist/types/src/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/diff.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,SAAS,WAAY,MAAM,SAAS,MAAM,KAAG,QAAQ,EAUjE,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,+DAA+D;AAC/D,eAAO,MAAM,SAAS,UAAW,QAAQ,EAAE,KAAG,SAW3C,CAAC;AAEJ,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACzE,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,MAAM,2BAA4B,WAAW,KAAG,YAwG5D,CAAC"}

package/dist/types/src/diff.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=diff.test.d.ts.map

package/dist/types/src/diff.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.test.d.ts","sourceRoot":"","sources":["../../../src/diff.test.ts"],"names":[],"mappings":""}

package/dist/types/src/index.d.ts

@@ -0,0 +1,5 @@
+export * as Branch from './Branch';
+export * as History from './History';
+export * as Version from './Version';
+export * from './diff';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,cAAc,QAAQ,CAAC"}

package/dist/types/src/internal/index.d.ts

@@ -0,0 +1,3 @@
+export * from './model';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/internal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/internal/index.ts"],"names":[],"mappings":"AAIA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}