@wildwinter/toolkit 0.2.1 → 0.2.2

package/dist/extensions.d.cts

@@ -209,6 +209,8 @@ declare function renameStages(target: TargetDecl, entry: Readonly<Record<string,
  *                   sorted by key, or in the authored order with `order: "preserve"`
  *   object(fields)  named keys by their own strategy, every other key by `other`
  *                   (atomic when absent)
+ *   comments        a list of comment threads, merged message by message
+ *                   (`mergeComments`)
  */
 type Strategy = {
     readonly kind: "atomic";
@@ -227,9 +229,12 @@ type Strategy = {
     readonly kind: "object";
     readonly fields: Readonly<Record<string, Strategy>>;
     readonly other?: Strategy;
+} | {
+    readonly kind: "comments";
 };
 declare const ATOMIC: Strategy;
 declare const SET: Strategy;
+declare const COMMENTS: Strategy;
 declare const mapOf: (of: Strategy) => Strategy;
 declare const keyedBy: (key: string, of: Strategy, opts?: {
     order?: "sorted" | "preserve";
@@ -267,6 +272,25 @@ interface TreeMergeOptions {
 declare function stableStringify(value: unknown): string;
 /** Three-way merge `base`, `ours` and `theirs` by `strategy`. A clash keeps ours. */
 declare function mergeTree(strategy: Strategy, base: unknown, ours: unknown, theirs: unknown, opts?: TreeMergeOptions): TreeMergeResult;
+/**
+ * Three-way merge two lists of comment threads, the shape both families'
+ * comments share: `{ id, messages: [{ author, ts, body, deleted? }], resolved?,
+ * ...}`. Lifted from Patter's merge (patterkit design/family-parity-2026-10.md
+ * item 5), where a thread merged whole made two replies to one thread clash.
+ *
+ * - Messages are keyed by author and timestamp, and are the union of both
+ *   sides', oldest first. A withdrawn message (a tombstone: body emptied,
+ *   `deleted` set) stays withdrawn whichever side withdrew it, and a message a
+ *   side removed outright, or lost with its whole thread, counts as withdrawn
+ *   by that side. One message edited two ways is a clash that keeps ours.
+ * - A thread's other fields (its anchor, its marker, `resolved`) merge one by
+ *   one, a field changed two ways being a clash; a thread one side removed
+ *   takes the other side's.
+ * - A thread with nothing readable left goes, as the editors drop it.
+ *
+ * Threads come back oldest first, by their first message, then by id.
+ */
+declare function mergeComments(base: unknown, ours: unknown, theirs: unknown, opts?: TreeMergeOptions): TreeMergeResult;
 /** How a value of this type merges (the README's table). */
 declare function strategyForType(decl: TypeDecl): Strategy;
 /** How one node's entry merges: field by field, each by its type. */
@@ -321,4 +345,4 @@ declare const atKey: (base: string, key: string) => string;
 /** `base` and then list position `i`. */
 declare const atIndex: (base: string, i: number) => string;
 
-export { ATOMIC, type ClaimDecl, type Conflict, type ConflictKind, type DataMergeResult, type ExtensionData, type FieldDecl, HOSTS, type HostName, type HostSpec, type JsonValue, MANIFEST_FILE_SUFFIX, MANIFEST_SCHEMA, type Manifest, type MergeWarning, type Problem, type ResolvedClaim, SCALAR_TYPES, SET, type ScalarType, type SettingDecl, type StageRename, type Strategy, type TargetDecl, type TreeMergeOptions, type TreeMergeResult, type TypeDecl, UNRESOLVED_KEY, type UnresolvedEntry, VALUE_TYPES, type ValueContext, type ValueType, atIndex, atKey, claimClashes, compileEntry, compiledTarget, defaultOf, effectiveClaim, entryProblems, extensionDataStrategy, keyedBy, manifestProblems, mapOf, markUnresolved, mergeExtensionData, mergeTree, objectOf, orphanedEntries, parseManifest, renameStages, resolvedClaims, settingValues, stableStringify, strategyForTarget, strategyForType, targetOf, unresolvedOf, unresolvedProblems, valueProblems, withoutMark };
+export { ATOMIC, COMMENTS, type ClaimDecl, type Conflict, type ConflictKind, type DataMergeResult, type ExtensionData, type FieldDecl, HOSTS, type HostName, type HostSpec, type JsonValue, MANIFEST_FILE_SUFFIX, MANIFEST_SCHEMA, type Manifest, type MergeWarning, type Problem, type ResolvedClaim, SCALAR_TYPES, SET, type ScalarType, type SettingDecl, type StageRename, type Strategy, type TargetDecl, type TreeMergeOptions, type TreeMergeResult, type TypeDecl, UNRESOLVED_KEY, type UnresolvedEntry, VALUE_TYPES, type ValueContext, type ValueType, atIndex, atKey, claimClashes, compileEntry, compiledTarget, defaultOf, effectiveClaim, entryProblems, extensionDataStrategy, keyedBy, manifestProblems, mapOf, markUnresolved, mergeComments, mergeExtensionData, mergeTree, objectOf, orphanedEntries, parseManifest, renameStages, resolvedClaims, settingValues, stableStringify, strategyForTarget, strategyForType, targetOf, unresolvedOf, unresolvedProblems, valueProblems, withoutMark };

package/dist/extensions.d.ts

@@ -209,6 +209,8 @@ declare function renameStages(target: TargetDecl, entry: Readonly<Record<string,
  *                   sorted by key, or in the authored order with `order: "preserve"`
  *   object(fields)  named keys by their own strategy, every other key by `other`
  *                   (atomic when absent)
+ *   comments        a list of comment threads, merged message by message
+ *                   (`mergeComments`)
  */
 type Strategy = {
     readonly kind: "atomic";
@@ -227,9 +229,12 @@ type Strategy = {
     readonly kind: "object";
     readonly fields: Readonly<Record<string, Strategy>>;
     readonly other?: Strategy;
+} | {
+    readonly kind: "comments";
 };
 declare const ATOMIC: Strategy;
 declare const SET: Strategy;
+declare const COMMENTS: Strategy;
 declare const mapOf: (of: Strategy) => Strategy;
 declare const keyedBy: (key: string, of: Strategy, opts?: {
     order?: "sorted" | "preserve";
@@ -267,6 +272,25 @@ interface TreeMergeOptions {
 declare function stableStringify(value: unknown): string;
 /** Three-way merge `base`, `ours` and `theirs` by `strategy`. A clash keeps ours. */
 declare function mergeTree(strategy: Strategy, base: unknown, ours: unknown, theirs: unknown, opts?: TreeMergeOptions): TreeMergeResult;
+/**
+ * Three-way merge two lists of comment threads, the shape both families'
+ * comments share: `{ id, messages: [{ author, ts, body, deleted? }], resolved?,
+ * ...}`. Lifted from Patter's merge (patterkit design/family-parity-2026-10.md
+ * item 5), where a thread merged whole made two replies to one thread clash.
+ *
+ * - Messages are keyed by author and timestamp, and are the union of both
+ *   sides', oldest first. A withdrawn message (a tombstone: body emptied,
+ *   `deleted` set) stays withdrawn whichever side withdrew it, and a message a
+ *   side removed outright, or lost with its whole thread, counts as withdrawn
+ *   by that side. One message edited two ways is a clash that keeps ours.
+ * - A thread's other fields (its anchor, its marker, `resolved`) merge one by
+ *   one, a field changed two ways being a clash; a thread one side removed
+ *   takes the other side's.
+ * - A thread with nothing readable left goes, as the editors drop it.
+ *
+ * Threads come back oldest first, by their first message, then by id.
+ */
+declare function mergeComments(base: unknown, ours: unknown, theirs: unknown, opts?: TreeMergeOptions): TreeMergeResult;
 /** How a value of this type merges (the README's table). */
 declare function strategyForType(decl: TypeDecl): Strategy;
 /** How one node's entry merges: field by field, each by its type. */
@@ -321,4 +345,4 @@ declare const atKey: (base: string, key: string) => string;
 /** `base` and then list position `i`. */
 declare const atIndex: (base: string, i: number) => string;
 
-export { ATOMIC, type ClaimDecl, type Conflict, type ConflictKind, type DataMergeResult, type ExtensionData, type FieldDecl, HOSTS, type HostName, type HostSpec, type JsonValue, MANIFEST_FILE_SUFFIX, MANIFEST_SCHEMA, type Manifest, type MergeWarning, type Problem, type ResolvedClaim, SCALAR_TYPES, SET, type ScalarType, type SettingDecl, type StageRename, type Strategy, type TargetDecl, type TreeMergeOptions, type TreeMergeResult, type TypeDecl, UNRESOLVED_KEY, type UnresolvedEntry, VALUE_TYPES, type ValueContext, type ValueType, atIndex, atKey, claimClashes, compileEntry, compiledTarget, defaultOf, effectiveClaim, entryProblems, extensionDataStrategy, keyedBy, manifestProblems, mapOf, markUnresolved, mergeExtensionData, mergeTree, objectOf, orphanedEntries, parseManifest, renameStages, resolvedClaims, settingValues, stableStringify, strategyForTarget, strategyForType, targetOf, unresolvedOf, unresolvedProblems, valueProblems, withoutMark };
+export { ATOMIC, COMMENTS, type ClaimDecl, type Conflict, type ConflictKind, type DataMergeResult, type ExtensionData, type FieldDecl, HOSTS, type HostName, type HostSpec, type JsonValue, MANIFEST_FILE_SUFFIX, MANIFEST_SCHEMA, type Manifest, type MergeWarning, type Problem, type ResolvedClaim, SCALAR_TYPES, SET, type ScalarType, type SettingDecl, type StageRename, type Strategy, type TargetDecl, type TreeMergeOptions, type TreeMergeResult, type TypeDecl, UNRESOLVED_KEY, type UnresolvedEntry, VALUE_TYPES, type ValueContext, type ValueType, atIndex, atKey, claimClashes, compileEntry, compiledTarget, defaultOf, effectiveClaim, entryProblems, extensionDataStrategy, keyedBy, manifestProblems, mapOf, markUnresolved, mergeComments, mergeExtensionData, mergeTree, objectOf, orphanedEntries, parseManifest, renameStages, resolvedClaims, settingValues, stableStringify, strategyForTarget, strategyForType, targetOf, unresolvedOf, unresolvedProblems, valueProblems, withoutMark };

package/dist/extensions.js

@@ -631,6 +631,7 @@ function effectiveClaim(claim, hostDecl) {
 // src/extensions/merge.ts
 var ATOMIC = { kind: "atomic" };
 var SET = { kind: "set" };
+var COMMENTS = { kind: "comments" };
 var mapOf = (of) => ({ kind: "map", of });
 var keyedBy = (key, of, opts) => ({
   kind: "keyed",
@@ -673,6 +674,7 @@ function hasShape(spec, v) {
       return true;
     case "set":
     case "keyed":
+    case "comments":
       return Array.isArray(v);
     case "map":
     case "object":
@@ -712,6 +714,8 @@ function mergeValue(spec, b, o, t, id, path, ctx) {
     }
     case "keyed":
       return mergeKeyed(spec, asArr(b), o, t, path, ctx);
+    case "comments":
+      return mergeThreads(asArr(b), o, t, path, ctx);
   }
 }
 function mergeKeyed(spec, B, O, T, path, ctx) {
@@ -790,6 +794,70 @@ function preservedOrder(B, O, T, survivors, path, ctx) {
   for (const k of [...survivors.keys()].sort()) if (!result.includes(k)) result.push(k);
   return result;
 }
+function mergeComments(base, ours, theirs, opts) {
+  return mergeTree(COMMENTS, base, ours, theirs, opts);
+}
+function mergeThreads(B, O, T, path, ctx) {
+  const index = (arr) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const c of arr) if (isObject(c) && typeof c["id"] === "string") m.set(c["id"], c);
+    return m;
+  };
+  const Bm = index(B), Om = index(O), Tm = index(T);
+  const out = [];
+  for (const id of /* @__PURE__ */ new Set([...Bm.keys(), ...Om.keys(), ...Tm.keys()])) {
+    const b = Bm.get(id), o = Om.get(id), t = Tm.get(id);
+    const here = `${path}[${id}]`;
+    if (o === void 0 && t === void 0) continue;
+    if (![b, o, t].some((c) => Array.isArray(c?.["messages"]))) {
+      const v = o !== void 0 && t !== void 0 ? merge3(b, o, t, id, here, ctx) : b !== void 0 && ctx.eq(o ?? t, b) ? void 0 : o ?? t;
+      if (isObject(v)) out.push(v);
+      continue;
+    }
+    const messages = mergeMessages(b, o, t, id, here, ctx);
+    if (messages.length === 0 || messages.every((m) => m["deleted"] === true)) continue;
+    const fields = {};
+    if (o !== void 0 && t !== void 0) {
+      const B0 = b ?? {};
+      const flag = (c, k) => k === "resolved" ? c[k] === true ? true : void 0 : c[k];
+      for (const k of /* @__PURE__ */ new Set([...Object.keys(o), ...Object.keys(t), ...Object.keys(B0)])) {
+        if (k === "messages") continue;
+        const v = merge3(flag(B0, k), flag(o, k), flag(t, k), id, `${here}.${k}`, ctx);
+        if (v !== void 0) fields[k] = v;
+      }
+    } else {
+      for (const [k, v] of Object.entries(o ?? t)) if (k !== "messages") fields[k] = v;
+    }
+    out.push({ ...fields, messages });
+  }
+  const first = (c) => {
+    const m = asArr(c["messages"])[0];
+    return isObject(m) && typeof m["ts"] === "string" ? m["ts"] : "";
+  };
+  return out.sort((x, y) => first(x).localeCompare(first(y)) || String(x["id"]).localeCompare(String(y["id"])));
+}
+function mergeMessages(b, o, t, id, here, ctx) {
+  const keyOf = (m) => `${String(m["author"] ?? "")}|${String(m["ts"] ?? "")}`;
+  const index = (c) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const x of asArr(c?.["messages"])) if (isObject(x)) m.set(keyOf(x), x);
+    return m;
+  };
+  const Bm = index(b), Om = index(o), Tm = index(t);
+  const out = [];
+  for (const k of /* @__PURE__ */ new Set([...Bm.keys(), ...Om.keys(), ...Tm.keys()])) {
+    const mb = Bm.get(k), mo = Om.get(k), mt = Tm.get(k);
+    if ([mb, mo, mt].some((m) => m?.["deleted"] === true) || mb !== void 0 && (mo === void 0 || mt === void 0)) {
+      out.push({ ...mo ?? mt ?? mb, body: "", deleted: true });
+    } else if (mo !== void 0 && mt !== void 0) {
+      out.push(merge3(mb, mo, mt, id, `${here}.messages[${k}]`, ctx));
+    } else {
+      out.push(mo ?? mt);
+    }
+  }
+  const ts = (m) => String(m["ts"] ?? "");
+  return out.sort((x, y) => ts(x).localeCompare(ts(y)) || String(x["author"] ?? "").localeCompare(String(y["author"] ?? "")));
+}
 function strategyForType(decl) {
   switch (decl.type) {
     case "flags":
@@ -897,6 +965,6 @@ function orphanedEntries(data, exists) {
   return out;
 }
 
-export { ATOMIC, HOSTS, MANIFEST_FILE_SUFFIX, MANIFEST_SCHEMA, SCALAR_TYPES, SET, UNRESOLVED_KEY, VALUE_TYPES, atIndex, atKey, claimClashes, compileEntry, compiledTarget, defaultOf, effectiveClaim, entryProblems, extensionDataStrategy, keyedBy, manifestProblems, mapOf, markUnresolved, mergeExtensionData, mergeTree, objectOf, orphanedEntries, parseManifest, renameStages, resolvedClaims, settingValues, stableStringify, strategyForTarget, strategyForType, targetOf, unresolvedOf, unresolvedProblems, valueProblems, withoutMark };
+export { ATOMIC, COMMENTS, HOSTS, MANIFEST_FILE_SUFFIX, MANIFEST_SCHEMA, SCALAR_TYPES, SET, UNRESOLVED_KEY, VALUE_TYPES, atIndex, atKey, claimClashes, compileEntry, compiledTarget, defaultOf, effectiveClaim, entryProblems, extensionDataStrategy, keyedBy, manifestProblems, mapOf, markUnresolved, mergeComments, mergeExtensionData, mergeTree, objectOf, orphanedEntries, parseManifest, renameStages, resolvedClaims, settingValues, stableStringify, strategyForTarget, strategyForType, targetOf, unresolvedOf, unresolvedProblems, valueProblems, withoutMark };
 //# sourceMappingURL=extensions.js.map
 //# sourceMappingURL=extensions.js.map