@vosjs/shared 0.1.0

package/dist/diff/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The semantic differ: pure functions over two
+ * immutable version states — no I/O, no recorded gesture log ("derive,
+ * don't record"). Runs identically in Workers, the CLI, and the studio;
+ * same two inputs ⇒ byte-identical ops and summary.
+ */
+interface Op {
+    op: 'add' | 'remove' | 'modify';
+    /**
+     * Doc tracks: zoom | tilt | speed | overlay | object | audio, plus scoped
+     * singletons (segments | frame | cursor | cam | export | camera).
+     * Config tracks: knob (param key space) | look | data | code | config.
+     */
+    track: string;
+    /** Span/clip id, param key, function name, or field name. */
+    id: string;
+    /** Changed properties: key → [from, to]. Absent on code ops. */
+    props?: Record<string, [unknown, unknown]>;
+    /** Code-function modifies only: magnitude of the line-level change. */
+    lines?: number;
+    /**
+     * True when the change is a cascaded consequence of another gesture
+     * (e.g. a trim shifting downstream spans), not a direct edit.
+     */
+    cascade?: boolean;
+}
+/** One intervening version's worth of changes, as the pull contract ships it. */
+interface VersionChanges {
+    versionId: string;
+    versionNumber: number;
+    origin: string;
+    label: string | null;
+    note: string | null;
+    ops: Op[];
+    summary: string;
+}
+/** Stable composite key for net-effect folding. */
+declare function opKey(op: Op): string;
+
+type AnyRecord = Record<string, unknown>;
+
+declare function diffConfig(a: AnyRecord, b: AnyRecord): Op[];
+
+declare function diffDoc(a: AnyRecord, b: AnyRecord): Op[];
+
+/**
+ * Net effect per node across a sequence of op sets (the coalescing rules):
+ * initial→final only, no intermediate drags. add→modify folds into the add;
+ * add→remove vanishes; modify chains keep the first `from` and last `to`
+ * (dropping props that net to no change); remove→add of the same id is one
+ * modify (the node was replaced in place). Output is deterministically
+ * ordered: track declaration order, then output-time anchor, then id.
+ */
+declare function coalesce(opsInOrder: readonly Op[]): Op[];
+
+/**
+ * Deterministic prose over an op list — the line that lands in the agent's
+ * context ("zoom z3: end 4.2s→4.6s, level 2.2→1.8; tilt t1 removed").
+ * Same ops ⇒ byte-identical string; unit-pinned like the geometry mirrors.
+ */
+declare function summarize(ops: readonly Op[], options?: {
+    maxItems?: number;
+}): string;
+
+export { type Op, type VersionChanges, coalesce, diffConfig, diffDoc, opKey, summarize };

package/dist/diff/index.js

@@ -0,0 +1,567 @@
+// src/diff/internal.ts
+function isRecord(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length) return false;
+    return ka.every((k) => deepEqual(a[k], b[k]));
+  }
+  return false;
+}
+function shallowDiff(a, b, ignore = /* @__PURE__ */ new Set()) {
+  const props = {};
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].sort();
+  for (const k of keys) {
+    if (ignore.has(k)) continue;
+    if (!deepEqual(a[k], b[k])) props[k] = [a[k], b[k]];
+  }
+  return Object.keys(props).length ? props : void 0;
+}
+function diffIdTrack(track, a, b) {
+  const ops = [];
+  const aById = new Map((a ?? []).map((n) => [String(n.id), n]));
+  const bById = new Map((b ?? []).map((n) => [String(n.id), n]));
+  for (const [id, node] of aById) {
+    if (!bById.has(id)) {
+      ops.push({ op: "remove", track, id, props: pickAnchor(node) });
+    }
+  }
+  for (const [id, node] of bById) {
+    const prev = aById.get(id);
+    if (!prev) {
+      ops.push({ op: "add", track, id, props: pickAnchor(node) });
+      continue;
+    }
+    const props = shallowDiff(prev, node, ID_KEYS);
+    if (props) ops.push({ op: "modify", track, id, props });
+  }
+  return ops;
+}
+var ID_KEYS = /* @__PURE__ */ new Set(["id"]);
+function pickAnchor(node) {
+  const out = {};
+  for (const k of ["in", "out", "at", "start", "kind", "key"]) {
+    if (node[k] !== void 0) out[k] = [void 0, node[k]];
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function lineDelta(a, b) {
+  const count = (s) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const line of s.split("\n")) m.set(line, (m.get(line) ?? 0) + 1);
+    return m;
+  };
+  const ca = count(a);
+  const cb = count(b);
+  let removed = 0;
+  let added = 0;
+  for (const [line, n] of ca) removed += Math.max(0, n - (cb.get(line) ?? 0));
+  for (const [line, n] of cb) added += Math.max(0, n - (ca.get(line) ?? 0));
+  return Math.max(added, removed);
+}
+
+// src/diff/diffConfig.ts
+var FUNCTION_FIELDS = ["setup", "createContent", "createTimeline", "onFrame"];
+var CONFIG_FIELDS = ["duration", "camera", "postprocessing", "elements"];
+function diffConfig(a, b) {
+  const ops = [];
+  const aParams = paramsByKey(a);
+  const bParams = paramsByKey(b);
+  const aData = isRecord(a.data) ? a.data : {};
+  const bData = isRecord(b.data) ? b.data : {};
+  const removedKeys = [];
+  const addedKeys = [];
+  for (const key of aParams.keys()) if (!bParams.has(key)) removedKeys.push(key);
+  for (const key of bParams.keys()) if (!aParams.has(key)) addedKeys.push(key);
+  const renamed = /* @__PURE__ */ new Map();
+  for (const oldKey of [...removedKeys]) {
+    const oldSpec = aParams.get(oldKey);
+    const match = addedKeys.find(
+      (newKey) => specEqualIgnoringIdentity(oldSpec, bParams.get(newKey))
+    );
+    if (match) {
+      renamed.set(oldKey, match);
+      removedKeys.splice(removedKeys.indexOf(oldKey), 1);
+      addedKeys.splice(addedKeys.indexOf(match), 1);
+    }
+  }
+  for (const [oldKey, newKey] of renamed) {
+    const props = {
+      key: [oldKey, newKey]
+    };
+    const fromVal = valueOf(aData, aParams.get(oldKey), oldKey);
+    const toVal = valueOf(bData, bParams.get(newKey), newKey);
+    if (!deepEqual(fromVal, toVal)) props.value = [fromVal, toVal];
+    ops.push({ op: "modify", track: "knob", id: newKey, props });
+  }
+  for (const key of removedKeys) {
+    ops.push({ op: "remove", track: "knob", id: key });
+  }
+  for (const key of addedKeys) {
+    const spec = bParams.get(key);
+    ops.push({
+      op: "add",
+      track: "knob",
+      id: key,
+      props: {
+        kind: [void 0, spec.kind],
+        value: [void 0, valueOf(bData, spec, key)]
+      }
+    });
+  }
+  for (const [key, aSpec] of aParams) {
+    const bSpec = bParams.get(key);
+    if (!bSpec) continue;
+    const props = {};
+    const aVal = valueOf(aData, aSpec, key);
+    const bVal = valueOf(bData, bSpec, key);
+    if (!deepEqual(aVal, bVal)) props.value = [aVal, bVal];
+    const specDiff = shallowDiff(aSpec, bSpec, KNOB_IDENTITY);
+    if (specDiff) {
+      if ("default" in specDiff && "value" in props) delete specDiff.default;
+      Object.assign(props, specDiff);
+    }
+    if (Object.keys(props).length) {
+      ops.push({ op: "modify", track: "knob", id: key, props });
+    }
+  }
+  const declared = /* @__PURE__ */ new Set([...aParams.keys(), ...bParams.keys()]);
+  const dataKeys = [
+    .../* @__PURE__ */ new Set([...Object.keys(aData), ...Object.keys(bData)])
+  ].sort();
+  for (const key of dataKeys) {
+    if (declared.has(key)) continue;
+    const from = aData[key];
+    const to = bData[key];
+    if (deepEqual(from, to)) continue;
+    const op = from === void 0 ? "add" : to === void 0 ? "remove" : "modify";
+    ops.push({ op, track: "data", id: key, props: { value: [from, to] } });
+  }
+  ops.push(
+    ...diffIdTrack("look", looksAsNodes(a.presets), looksAsNodes(b.presets))
+  );
+  for (const fn of FUNCTION_FIELDS) {
+    const va = a[fn];
+    const vb = b[fn];
+    const fa = typeof va === "string" ? va : "";
+    const fb = typeof vb === "string" ? vb : "";
+    if (fa === fb) continue;
+    ops.push({
+      op: "modify",
+      track: "code",
+      id: fn,
+      lines: lineDelta(fa, fb)
+    });
+  }
+  for (const field of CONFIG_FIELDS) {
+    if (deepEqual(a[field], b[field])) continue;
+    ops.push({
+      op: "modify",
+      track: "config",
+      id: field,
+      props: { value: [a[field], b[field]] }
+    });
+  }
+  return ops;
+}
+var KNOB_IDENTITY = /* @__PURE__ */ new Set(["key", "label", "order"]);
+function paramsByKey(config) {
+  const out = /* @__PURE__ */ new Map();
+  if (!Array.isArray(config.params)) return out;
+  for (const entry of config.params) {
+    if (isRecord(entry) && typeof entry.key === "string" && entry.key) {
+      out.set(entry.key, entry);
+    }
+  }
+  return out;
+}
+function valueOf(data, spec, key) {
+  return data[key] !== void 0 ? data[key] : spec.default;
+}
+function specEqualIgnoringIdentity(a, b) {
+  return !shallowDiff(a, b, KNOB_IDENTITY);
+}
+function looksAsNodes(presets) {
+  if (!Array.isArray(presets)) return [];
+  return presets.filter((p) => isRecord(p) && typeof p.name === "string").map((p) => ({ ...p, id: p.name }));
+}
+
+// src/diff/diffDoc.ts
+var ID_TRACKS = [
+  ["zoom", "zoom"],
+  ["tilt", "tilt"],
+  ["camMove", "camMotion"],
+  ["speed", "speed"],
+  ["overlay", "overlays"],
+  ["object", "objects"],
+  ["audio", "audio"]
+];
+var SCOPED_FIELDS = ["frame", "cursor", "cam", "export"];
+function diffDoc(a, b) {
+  const ops = [];
+  const pa = isRecord(a.program) ? a.program : void 0;
+  const pb = isRecord(b.program) ? b.program : void 0;
+  if (pa || pb) {
+    ops.push(
+      ...diffConfig(
+        pa && isRecord(pa.config) ? pa.config : {},
+        pb && isRecord(pb.config) ? pb.config : {}
+      )
+    );
+    const ea = pa && isRecord(pa.tweenEdits) ? pa.tweenEdits : {};
+    const eb = pb && isRecord(pb.tweenEdits) ? pb.tweenEdits : {};
+    for (const key of /* @__PURE__ */ new Set([...Object.keys(ea), ...Object.keys(eb)])) {
+      const va = isRecord(ea[key]) ? ea[key] : void 0;
+      const vb = isRecord(eb[key]) ? eb[key] : void 0;
+      if (va && !vb) ops.push({ op: "remove", track: "tween", id: `#${key}` });
+      else if (!va && vb) ops.push({ op: "add", track: "tween", id: `#${key}` });
+      else if (va && vb) {
+        const props = shallowDiff(va, vb);
+        if (props)
+          ops.push({ op: "modify", track: "tween", id: `#${key}`, props });
+      }
+    }
+    const da = programLength(pa);
+    const db = programLength(pb);
+    if (da !== db && (pa?.duration !== void 0 || pb?.duration !== void 0)) {
+      ops.push({
+        op: "modify",
+        track: "config",
+        id: "duration",
+        props: { value: [da, db] }
+      });
+    }
+  }
+  for (const [track, field] of ID_TRACKS) {
+    ops.push(...diffIdTrack(track, asNodeList(a[field]), asNodeList(b[field])));
+  }
+  const speedOps = ops.filter((o) => o.track === "speed");
+  if (speedOps.length) {
+    const [oa, ob] = [outputDuration(a), outputDuration(b)];
+    if (oa !== null && ob !== null && Math.abs(oa - ob) >= 0.05) {
+      speedOps[0].props = { ...speedOps[0].props ?? {}, output: [oa, ob] };
+    }
+  }
+  const aSeg = asNodeList(a.segments) ?? [];
+  const bSeg = asNodeList(b.segments) ?? [];
+  if (!deepEqual(a.segments, b.segments)) {
+    const props = {};
+    if (aSeg.length !== bSeg.length) props.count = [aSeg.length, bSeg.length];
+    const [da, db] = [keptDuration(aSeg), keptDuration(bSeg)];
+    if (da !== db) props.duration = [da, db];
+    ops.push({
+      op: "modify",
+      track: "segments",
+      id: "segments",
+      props: Object.keys(props).length ? props : { value: ["edited", "edited"] }
+    });
+  }
+  for (const field of SCOPED_FIELDS) {
+    const va = a[field];
+    const vb = b[field];
+    const fa = isRecord(va) ? va : {};
+    const fb = isRecord(vb) ? vb : {};
+    const props = shallowDiff(fa, fb);
+    if (props) ops.push({ op: "modify", track: field, id: field, props });
+  }
+  const cameraProps = {};
+  for (const k of ["zoomStyle", "tiltStyle", "micGain"]) {
+    if (!deepEqual(a[k], b[k])) cameraProps[k] = [a[k], b[k]];
+  }
+  if (!deepEqual(a.zoomParams, b.zoomParams)) {
+    cameraProps.zoomParams = [a.zoomParams, b.zoomParams];
+  }
+  if (Object.keys(cameraProps).length) {
+    ops.push({
+      op: "modify",
+      track: "camera",
+      id: "camera",
+      props: cameraProps
+    });
+  }
+  return ops;
+}
+function asNodeList(v) {
+  if (!Array.isArray(v)) return void 0;
+  return v.filter(isRecord);
+}
+function programLength(program) {
+  if (!program) return null;
+  if (typeof program.duration === "number") return program.duration;
+  const cfg = isRecord(program.config) ? program.config : void 0;
+  return cfg && typeof cfg.duration === "number" ? cfg.duration : null;
+}
+function outputDuration(doc) {
+  const source = isRecord(doc.source) ? doc.source : void 0;
+  const meta = source && isRecord(source.meta) ? source.meta : void 0;
+  const durS = isRecord(doc.program) ? programLength(doc.program) : meta && typeof meta.durationMs === "number" ? meta.durationMs / 1e3 : null;
+  const explicit = (asNodeList(doc.segments) ?? []).map((s) => ({
+    in: typeof s.in === "number" ? s.in : 0,
+    out: typeof s.out === "number" ? s.out : 0
+  })).filter((s) => s.out > s.in);
+  const segments = explicit.length ? explicit : durS !== null ? [{ in: 0, out: durS }] : null;
+  if (!segments) return null;
+  const spans = (asNodeList(doc.speed) ?? []).map((s) => ({
+    in: typeof s.in === "number" ? s.in : 0,
+    out: typeof s.out === "number" ? s.out : 0,
+    rate: typeof s.rate === "number" && s.rate > 0 ? s.rate : 1
+  })).filter((s) => s.out > s.in);
+  let total = 0;
+  for (const seg of segments) {
+    total += seg.out - seg.in;
+    for (const sp of spans) {
+      const ov = Math.min(seg.out, sp.out) - Math.max(seg.in, sp.in);
+      if (ov > 0) total -= ov - ov / sp.rate;
+    }
+  }
+  return Math.round(total * 1e3) / 1e3;
+}
+function keptDuration(segments) {
+  let total = 0;
+  for (const s of segments) {
+    const start = typeof s.in === "number" ? s.in : 0;
+    const end = typeof s.out === "number" ? s.out : start;
+    total += Math.max(0, end - start);
+  }
+  return Math.round(total * 1e3) / 1e3;
+}
+
+// src/diff/types.ts
+function opKey(op) {
+  return `${op.track}\0${op.id}`;
+}
+
+// src/diff/coalesce.ts
+function coalesce(opsInOrder) {
+  const byNode = /* @__PURE__ */ new Map();
+  for (const next of opsInOrder) {
+    const key = opKey(next);
+    const prev = byNode.get(key);
+    if (!prev) {
+      byNode.set(key, cloneOp(next));
+      continue;
+    }
+    const folded = foldPair(prev, next);
+    if (folded) byNode.set(key, folded);
+    else byNode.delete(key);
+  }
+  return [...byNode.values()].sort(compareOps);
+}
+function foldPair(prev, next) {
+  if (prev.op === "add" && next.op === "remove") return null;
+  if (prev.op === "add" && next.op === "modify") {
+    return { ...prev, props: mergeProps(prev.props, next.props) };
+  }
+  if (next.op === "remove") return { ...next };
+  if (prev.op === "remove" && next.op === "add") {
+    return { ...next, op: "modify", props: mergeProps(prev.props, next.props) };
+  }
+  if (prev.op === "modify" && next.op === "modify") {
+    const merged = mergeProps(prev.props, next.props, true);
+    const lines = prev.lines !== void 0 || next.lines !== void 0 ? (prev.lines ?? 0) + (next.lines ?? 0) : void 0;
+    if (!merged && lines === void 0) return null;
+    return { ...prev, props: merged, lines };
+  }
+  return { ...next };
+}
+function mergeProps(a, b, dropNoNet = false) {
+  if (!a) return b ? { ...b } : void 0;
+  if (!b) return { ...a };
+  const out = { ...a };
+  for (const [k, [from, to]] of Object.entries(b)) {
+    out[k] = k in out ? [out[k][0], to] : [from, to];
+  }
+  if (dropNoNet) {
+    for (const [k, [from, to]] of Object.entries(out)) {
+      if (JSON.stringify(from) === JSON.stringify(to)) delete out[k];
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function cloneOp(op) {
+  return { ...op, props: op.props ? { ...op.props } : void 0 };
+}
+var TRACK_ORDER = [
+  "segments",
+  "frame",
+  "camera",
+  "cursor",
+  "cam",
+  "zoom",
+  "tilt",
+  "speed",
+  "overlay",
+  "object",
+  "audio",
+  "export",
+  "knob",
+  "look",
+  "data",
+  "code",
+  "config"
+];
+function compareOps(a, b) {
+  const ta = TRACK_ORDER.indexOf(a.track);
+  const tb = TRACK_ORDER.indexOf(b.track);
+  if (ta !== tb) return (ta === -1 ? 99 : ta) - (tb === -1 ? 99 : tb);
+  const anchorA = timeAnchor(a);
+  const anchorB = timeAnchor(b);
+  if (anchorA !== anchorB) return anchorA - anchorB;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+function timeAnchor(op) {
+  for (const k of ["in", "at", "start"]) {
+    const pair = op.props?.[k];
+    if (pair) {
+      const v = pair[1] ?? pair[0];
+      if (typeof v === "number") return v;
+    }
+  }
+  return Number.MAX_SAFE_INTEGER;
+}
+
+// src/diff/summarize.ts
+function summarize(ops, options = {}) {
+  const max = options.maxItems ?? 12;
+  if (ops.length === 0) return "no changes";
+  const shown = ops.slice(0, max);
+  const parts = shown.map(phrase);
+  const hidden = ops.length - shown.length;
+  if (hidden > 0)
+    parts.push(`and ${hidden} smaller change${hidden === 1 ? "" : "s"}`);
+  return parts.join("; ");
+}
+function phrase(op) {
+  if (op.track === "code") {
+    return `code ${op.id} changed (${op.lines ?? 0} line${op.lines === 1 ? "" : "s"})`;
+  }
+  if (op.track === "knob") return knobPhrase(op);
+  if (op.track === "config") {
+    if (op.id === "duration" && op.props?.value) {
+      const [from, to] = op.props.value;
+      return `duration ${fmt(from, true)}\u2192${fmt(to, true)}`;
+    }
+    return `${op.id} changed`;
+  }
+  if (op.track === "data") {
+    const pair = op.props?.value;
+    if (op.op === "add") return `data ${op.id} set to ${fmt(pair?.[1])}`;
+    if (op.op === "remove") return `data ${op.id} removed`;
+    return `data ${op.id}: ${fmt(pair?.[0])}\u2192${fmt(pair?.[1])}`;
+  }
+  if (op.track === "look") {
+    if (op.op === "add") return `look "${op.id}" added`;
+    if (op.op === "remove") return `look "${op.id}" removed`;
+    return `look "${op.id}" changed`;
+  }
+  if (op.track === "segments") {
+    const d = op.props?.duration;
+    if (d) return `trim: kept footage ${fmt(d[0], true)}\u2192${fmt(d[1], true)}`;
+    return "segments edited";
+  }
+  if (SCOPED_TRACKS.has(op.track)) {
+    return `${op.track} ${propList(op.props)}`;
+  }
+  const name = `${op.track} ${op.id}`;
+  const output = op.props?.output;
+  const outputNote = output ? `output ${fmt(output[0], true)}\u2192${fmt(output[1], true)}` : null;
+  if (op.op === "add") {
+    const range = rangeOf(op);
+    const bits = [range, outputNote].filter(Boolean).join(", ");
+    return bits ? `${name} added (${bits})` : `${name} added`;
+  }
+  if (op.op === "remove")
+    return outputNote ? `${name} removed (${outputNote})` : `${name} removed`;
+  return `${name}: ${propList(op.props)}`;
+}
+function knobPhrase(op) {
+  const rename = op.props?.key;
+  if (rename) return `replaced knob ${fmt(rename[0])} with ${fmt(rename[1])}`;
+  if (op.op === "add") {
+    const kind = (op.props?.kind ?? [])[1];
+    return typeof kind === "string" ? `knob ${op.id} added (${kind})` : `knob ${op.id} added`;
+  }
+  if (op.op === "remove") return `knob ${op.id} removed`;
+  const value = op.props?.value;
+  const parts = [];
+  if (value) parts.push(`${fmt(value[0])}\u2192${fmt(value[1])}`);
+  for (const [k, [from, to]] of Object.entries(op.props ?? {})) {
+    if (k === "value") continue;
+    parts.push(`${k} ${fmt(from)}\u2192${fmt(to)}`);
+  }
+  return `knob ${op.id}: ${parts.join(", ")}`;
+}
+var SCOPED_TRACKS = /* @__PURE__ */ new Set(["frame", "cursor", "cam", "export", "camera"]);
+var PROP_LABELS = {
+  in: "start",
+  out: "end",
+  cx: "focus x",
+  cy: "focus y"
+};
+var TIME_PROPS = /* @__PURE__ */ new Set([
+  "in",
+  "out",
+  "at",
+  "start",
+  "end",
+  "duration",
+  "output"
+]);
+function propList(props) {
+  if (!props) return "changed";
+  return Object.entries(props).map(([k, [from, to]]) => {
+    const time = TIME_PROPS.has(k);
+    return `${PROP_LABELS[k] ?? k} ${fmt(from, time)}\u2192${fmt(to, time)}`;
+  }).join(", ");
+}
+function rangeOf(op) {
+  const startPair = anchorPair(op, ["in", "at", "start"]);
+  const start = startPair ? startPair[1] : void 0;
+  if (typeof start !== "number") return null;
+  const endPair = anchorPair(op, ["out"]);
+  const end = endPair ? endPair[1] : void 0;
+  return typeof end === "number" ? `${fmt(start, true)}\u2013${fmt(end, true)}` : `at ${fmt(start, true)}`;
+}
+function anchorPair(op, keys) {
+  for (const k of keys) {
+    const pair = op.props?.[k];
+    if (pair) return pair;
+  }
+  return void 0;
+}
+var FMT_STRING_MAX = 40;
+function fmt(v, time = false) {
+  if (v === void 0) return "\u2205";
+  if (v === null) return "null";
+  if (typeof v === "number") {
+    const rounded = Math.round(v * 100) / 100;
+    return time ? `${rounded}s` : String(rounded);
+  }
+  if (typeof v === "boolean") return v ? "on" : "off";
+  if (typeof v === "string") {
+    if (v === "") return '""';
+    const flat = v.replace(/\s*\n\s*/g, " ");
+    const clipped = flat.length > FMT_STRING_MAX ? `${flat.slice(0, FMT_STRING_MAX - 1)}\u2026` : flat;
+    return clipped === v ? quoteIfNeeded(clipped) : `"${clipped}"`;
+  }
+  return "changed";
+}
+function quoteIfNeeded(s) {
+  return /^[\w.#-]+$/.test(s) ? s : `"${s}"`;
+}
+export {
+  coalesce,
+  diffConfig,
+  diffDoc,
+  opKey,
+  summarize
+};
+//# sourceMappingURL=index.js.map