@issuegraph/store 0.1.0

package/dist/adapters/scripted.js

@@ -0,0 +1,89 @@
+/**
+ * The scripted adapter: asynchronous, and able to fail on purpose.
+ *
+ * It is a second adapter rather than the in-memory one with a flag, and the
+ * structural difference is deliberate: **it does not settle until it is told
+ * to.** That is the only way to observe the store mid-flight, which is the only
+ * way to assert that the order stays put while a write is pending — and a flag
+ * on a synchronous adapter could never provide it.
+ *
+ * Two audiences. Inside this package it is what induces `failed` and `conflict`
+ * rather than asserting they exist. Outside it, it is the harness a host writes
+ * its own adapter's tests against, which is why it ships rather than living in
+ * a test file.
+ */
+/**
+ * A data source that hands control of every settlement to its caller.
+ *
+ * `seed` is what it hydrates. `apply` computes the document an `'applied'`
+ * settlement produces — injected rather than reimplemented here, so a test can
+ * reuse an in-memory source's behaviour or supply its own without this adapter
+ * growing a second copy of the edit semantics.
+ */
+export function createScriptedSource(seed, apply) {
+    let document = { issues: [...seed.issues], edges: [...seed.edges] };
+    const waiting = [];
+    let watchers = [];
+    function take(mutationId) {
+        const index = mutationId === undefined
+            ? 0
+            : waiting.findIndex((entry) => entry.mutationId === mutationId);
+        const entry = index < 0 ? undefined : waiting[index];
+        if (entry === undefined) {
+            throw new Error(mutationId === undefined
+                ? 'scripted source: nothing is waiting to be settled'
+                : `scripted source: ${mutationId} is not waiting to be settled`);
+        }
+        waiting.splice(index, 1);
+        return entry;
+    }
+    function answer(entry, outcome) {
+        if (outcome === 'unchanged') {
+            entry.resolve({ outcome: 'unchanged', document });
+            return;
+        }
+        if (outcome !== 'applied') {
+            entry.resolve(outcome);
+            return;
+        }
+        document = apply(document, entry.mutation);
+        entry.resolve({ outcome: 'applied', document });
+    }
+    return {
+        current: () => document,
+        pending: () => waiting.map(({ mutationId, mutation }) => ({ mutationId, mutation })),
+        hydrate: () => Promise.resolve(document),
+        dispatch(mutation) {
+            const settlement = new Promise((resolve, reject) => {
+                waiting.push({ mutationId: mutation.mutationId, mutation, resolve, reject });
+            });
+            const entry = { mutationId: mutation.mutationId, mutation };
+            const matched = watchers.filter((watcher) => watcher.mutationId === undefined || watcher.mutationId === mutation.mutationId);
+            watchers = watchers.filter((watcher) => !matched.includes(watcher));
+            for (const watcher of matched)
+                watcher.notify(entry);
+            return settlement;
+        },
+        whenPending(mutationId) {
+            const already = mutationId === undefined
+                ? waiting[0]
+                : waiting.find((entry) => entry.mutationId === mutationId);
+            if (already !== undefined) {
+                return Promise.resolve({ mutationId: already.mutationId, mutation: already.mutation });
+            }
+            return new Promise((resolve) => {
+                watchers.push({ mutationId, notify: resolve });
+            });
+        },
+        settleNext(outcome) {
+            answer(take(undefined), outcome);
+        },
+        settle(mutationId, outcome) {
+            answer(take(mutationId), outcome);
+        },
+        throwNext(error) {
+            take(undefined).reject(error);
+        },
+    };
+}
+//# sourceMappingURL=scripted.js.map

package/dist/adapters/scripted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scripted.js","sourceRoot":"","sources":["../../src/adapters/scripted.ts"],"names":[],"mappings":"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"}

package/dist/change.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The re-evaluate loop: what an edit did to the order, as data.
+ *
+ * The design's answer to "how does an owner see cause and effect without
+ * re-scanning three hundred rows" is a one-line blast-radius summary plus a
+ * delta chip on ONLY the rows that changed. This module computes both — and
+ * stops there.
+ *
+ * Two things it deliberately does not do:
+ *
+ * - **It does not derive an order.** It diffs two orders it is handed. A sort
+ *   in here would be the second derivation the reference packages exist to
+ *   avoid having.
+ * - **It does not format a sentence.** The summary's counts ship as numbers, so
+ *   a host writes "3 rows moved · 1 promoted" in its own words and its own
+ *   language. A package that shipped the string would ship a language choice
+ *   its consumers could not theme away.
+ *
+ * And one thing it must never grow: a timer. The design rejects the toast
+ * precisely because the only evidence the edit worked disappears before it is
+ * read. `lastChange` persists until the next edit or an explicit dismissal.
+ */
+import type { IssueRef } from './model.ts';
+import type { Mutation } from './mutation.ts';
+import type { OrderRow } from './source.ts';
+/** How far and which way a row moved. */
+export interface RankMovement {
+    readonly direction: 'up' | 'down';
+    /** Positions travelled. Always positive. */
+    readonly by: number;
+    readonly from: number;
+    readonly to: number;
+}
+/**
+ * What happened to one row. Only rows that changed get one, and a row can have
+ * changed in more than one way at once — being promoted usually moves you.
+ */
+export interface RankDelta {
+    readonly ref: IssueRef;
+    readonly movement?: RankMovement;
+    /** `promoted` = held became ready. `newly-held` = the reverse. */
+    readonly readiness?: 'promoted' | 'newly-held';
+    /** Rows entering or leaving the order entirely (a `duplicate-of`, a closure). */
+    readonly presence?: 'entered' | 'left';
+}
+/** The blast radius, as counts a host can render into its own sentence. */
+export interface ChangeCounts {
+    readonly moved: number;
+    readonly promoted: number;
+    readonly newlyHeld: number;
+    readonly entered: number;
+    readonly left: number;
+}
+/**
+ * What the last landed edit did to the order.
+ *
+ * An edit that lands and moves nothing still produces one, with an empty
+ * `deltas` and all-zero counts. "This edit changed nothing" is a FINDING — it
+ * is the one an owner auditing an encoding most needs — and reporting it as the
+ * absence of a change would hide it.
+ */
+export interface OrderChange {
+    readonly mutation: Mutation;
+    readonly deltas: readonly RankDelta[];
+    readonly counts: ChangeCounts;
+}
+/**
+ * The deltas between two orders, for the rows that changed and no others.
+ *
+ * Rows that did not move, did not change readiness and did not enter or leave
+ * appear nowhere in the result — which is what lets a viewer leave them
+ * completely alone rather than re-rendering the whole rail.
+ */
+export declare function diffOrder(previous: readonly OrderRow[], next: readonly OrderRow[], mutation: Mutation): OrderChange;
+//# sourceMappingURL=change.d.ts.map

package/dist/change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change.d.ts","sourceRoot":"","sources":["../src/change.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,yCAAyC;AACzC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;IAClC,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACjC,kEAAkE;IAClE,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC;IAC/C,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CACxC;AAED,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAMD;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,QAAQ,EAAE,QAAQ,GACjB,WAAW,CAgDb"}

package/dist/change.js

@@ -0,0 +1,79 @@
+/**
+ * The re-evaluate loop: what an edit did to the order, as data.
+ *
+ * The design's answer to "how does an owner see cause and effect without
+ * re-scanning three hundred rows" is a one-line blast-radius summary plus a
+ * delta chip on ONLY the rows that changed. This module computes both — and
+ * stops there.
+ *
+ * Two things it deliberately does not do:
+ *
+ * - **It does not derive an order.** It diffs two orders it is handed. A sort
+ *   in here would be the second derivation the reference packages exist to
+ *   avoid having.
+ * - **It does not format a sentence.** The summary's counts ship as numbers, so
+ *   a host writes "3 rows moved · 1 promoted" in its own words and its own
+ *   language. A package that shipped the string would ship a language choice
+ *   its consumers could not theme away.
+ *
+ * And one thing it must never grow: a timer. The design rejects the toast
+ * precisely because the only evidence the edit worked disappears before it is
+ * read. `lastChange` persists until the next edit or an explicit dismissal.
+ */
+function byRef(rows) {
+    return new Map(rows.map((row) => [row.ref, row]));
+}
+/**
+ * The deltas between two orders, for the rows that changed and no others.
+ *
+ * Rows that did not move, did not change readiness and did not enter or leave
+ * appear nowhere in the result — which is what lets a viewer leave them
+ * completely alone rather than re-rendering the whole rail.
+ */
+export function diffOrder(previous, next, mutation) {
+    const before = byRef(previous);
+    const after = byRef(next);
+    const deltas = [];
+    for (const row of next) {
+        const was = before.get(row.ref);
+        if (was === undefined) {
+            deltas.push({ ref: row.ref, presence: 'entered' });
+            continue;
+        }
+        const movement = was.rank === row.rank
+            ? undefined
+            : {
+                direction: row.rank < was.rank ? 'up' : 'down',
+                by: Math.abs(row.rank - was.rank),
+                from: was.rank,
+                to: row.rank,
+            };
+        const readiness = was.ready === row.ready ? undefined : row.ready ? 'promoted' : 'newly-held';
+        if (movement === undefined && readiness === undefined)
+            continue;
+        // Keys are omitted rather than set to `undefined`: `exactOptionalPropertyTypes`
+        // is on, and a host reading `'movement' in delta` must not see a key that is
+        // there but empty.
+        deltas.push({
+            ref: row.ref,
+            ...(movement === undefined ? {} : { movement }),
+            ...(readiness === undefined ? {} : { readiness }),
+        });
+    }
+    for (const row of previous) {
+        if (!after.has(row.ref))
+            deltas.push({ ref: row.ref, presence: 'left' });
+    }
+    return {
+        mutation,
+        deltas,
+        counts: {
+            moved: deltas.filter((delta) => delta.movement !== undefined).length,
+            promoted: deltas.filter((delta) => delta.readiness === 'promoted').length,
+            newlyHeld: deltas.filter((delta) => delta.readiness === 'newly-held').length,
+            entered: deltas.filter((delta) => delta.presence === 'entered').length,
+            left: deltas.filter((delta) => delta.presence === 'left').length,
+        },
+    };
+}
+//# sourceMappingURL=change.js.map

package/dist/change.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"change.js","sourceRoot":"","sources":["../src/change.ts"],"names":[],"mappings":"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"}

package/dist/equality.d.ts

@@ -0,0 +1,27 @@
+/**
+ * One structural comparison, used by every slice the store reuses.
+ *
+ * A comparator that lists the fields it cares about is a staleness bug waiting
+ * for the next field: leave one off and the slice compares equal, the old one
+ * is republished, and a host renders state the store has already replaced.
+ *
+ * A list of fields is the defect, not any particular list. Nothing here
+ * enumerates anything, so a field added tomorrow is compared tomorrow.
+ *
+ * The one comparator that stays bespoke is `sameEdgeSet`, and for a reason
+ * this cannot express: it is deliberately order-INSENSITIVE, because an adapter
+ * may return its edges in whatever order its storage yields and a reordering is
+ * not a change.
+ */
+/**
+ * Whether two values say the same thing, all the way down.
+ *
+ * `Object.is` at the top, so a reference match short-circuits and `NaN`
+ * compares equal to itself — which matters because a rank is a number and a
+ * deriver that produces `NaN` should not make every snapshot look different
+ * from the last one for ever.
+ */
+export declare function sameValue(a: unknown, b: unknown, depth?: number): boolean;
+/** Whether two lists say the same thing, element for element and in order. */
+export declare function sameList(a: readonly unknown[], b: readonly unknown[]): boolean;
+//# sourceMappingURL=equality.d.ts.map

package/dist/equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality.d.ts","sourceRoot":"","sources":["../src/equality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAiBH;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,OAAO,CAgBpE;AAED,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAE9E"}

package/dist/equality.js

@@ -0,0 +1,60 @@
+/**
+ * One structural comparison, used by every slice the store reuses.
+ *
+ * A comparator that lists the fields it cares about is a staleness bug waiting
+ * for the next field: leave one off and the slice compares equal, the old one
+ * is republished, and a host renders state the store has already replaced.
+ *
+ * A list of fields is the defect, not any particular list. Nothing here
+ * enumerates anything, so a field added tomorrow is compared tomorrow.
+ *
+ * The one comparator that stays bespoke is `sameEdgeSet`, and for a reason
+ * this cannot express: it is deliberately order-INSENSITIVE, because an adapter
+ * may return its edges in whatever order its storage yields and a reordering is
+ * not a change.
+ */
+/**
+ * How deep a comparison will go before giving up and reporting "different".
+ *
+ * A bound rather than cycle tracking, because the failure it guards is a host
+ * value the store did not build — a row from an injected deriver — and the
+ * safe direction is obvious: over-reporting a change costs one redundant
+ * publish, while looping costs the process. Nothing the store itself builds is
+ * more than a handful of levels deep.
+ */
+const MAX_DEPTH = 100;
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Whether two values say the same thing, all the way down.
+ *
+ * `Object.is` at the top, so a reference match short-circuits and `NaN`
+ * compares equal to itself — which matters because a rank is a number and a
+ * deriver that produces `NaN` should not make every snapshot look different
+ * from the last one for ever.
+ */
+export function sameValue(a, b, depth = 0) {
+    if (Object.is(a, b))
+        return true;
+    if (depth >= MAX_DEPTH)
+        return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, index) => sameValue(item, b[index], depth + 1));
+    }
+    if (!isPlainObject(a) || !isPlainObject(b))
+        return false;
+    const keys = Object.keys(a);
+    // Counted both ways, so a key present on one side and absent on the other is
+    // a difference even when every shared key matches.
+    if (keys.length !== Object.keys(b).length)
+        return false;
+    return keys.every((key) => Object.hasOwn(b, key) && sameValue(a[key], b[key], depth + 1));
+}
+/** Whether two lists say the same thing, element for element and in order. */
+export function sameList(a, b) {
+    return sameValue(a, b);
+}
+//# sourceMappingURL=equality.js.map

package/dist/equality.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality.js","sourceRoot":"","sources":["../src/equality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,MAAM,SAAS,GAAG,GAAG,CAAC;AAEtB,SAAS,aAAa,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CAAC,CAAU,EAAE,CAAU,EAAE,KAAK,GAAG,CAAC;IACzD,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACjC,IAAI,KAAK,IAAI,SAAS;QAAE,OAAO,KAAK,CAAC;IAErC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAClF,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC;IAED,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IAEzD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC5B,6EAA6E;IAC7E,mDAAmD;IACnD,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IACxD,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;AAC5F,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,QAAQ,CAAC,CAAqB,EAAE,CAAqB;IACnE,OAAO,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACzB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@issuegraph/store` — a client store for an Issuegraph document, and the port
+ * a host plugs its tracker in through.
+ *
+ * The package fetches nothing, authenticates nothing and persists nothing. It
+ * holds the document, renders edits optimistically, dispatches every one of
+ * them outward, and refuses to re-evaluate the selection order until a write
+ * has actually landed.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+export { type EdgeId, type EdgeKind, type GraphDocument, type IssueRef, type IssueState, type StoredEdge, type StoredIssue, edgeId, findEdge, hasIssue, makeEdge, sameEdgeSet, } from './model.ts';
+export { type EdgeState, type InvalidCode, type InvalidReason, type Mutation, type MutationId, type Proposal, EDGE_STATES, INVALID_CODES, isEdgeState, } from './mutation.ts';
+export type { DataSource, DispatchResult, EdgeGuard, EdgeGuardContext, OrderDeriver, OrderRow, } from './source.ts';
+export { type EdgeChange, edgeChangeFor, nextDocument, resultingEdge, structuralRefusal, } from './validity.ts';
+export { type ProjectedEdge, type WriteRecord, anyPending, edgeStateOf, project } from './write.ts';
+export { sameList, sameValue } from './equality.ts';
+export { type ChangeCounts, type OrderChange, type RankDelta, type RankMovement, diffOrder, } from './change.ts';
+export { type HydrationStatus, type OrderStatus, type OrderView, type ProposalHandle, type Store, type StoreConfig, type StoreSnapshot, createStore, } from './store.ts';
+export { type MemorySource, createMemorySource } from './adapters/memory.ts';
+export { type PendingDispatch, type ScriptedOutcome, type ScriptedSource, createScriptedSource, } from './adapters/scripted.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,WAAW,EACX,aAAa,EACb,WAAW,GACZ,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,UAAU,EACV,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,QAAQ,GACT,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,KAAK,UAAU,EACf,aAAa,EACb,YAAY,EACZ,aAAa,EACb,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEpG,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,SAAS,GACV,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,KAAK,EACV,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * `@issuegraph/store` — a client store for an Issuegraph document, and the port
+ * a host plugs its tracker in through.
+ *
+ * The package fetches nothing, authenticates nothing and persists nothing. It
+ * holds the document, renders edits optimistically, dispatches every one of
+ * them outward, and refuses to re-evaluate the selection order until a write
+ * has actually landed.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+export { edgeId, findEdge, hasIssue, makeEdge, sameEdgeSet, } from "./model.js";
+export { EDGE_STATES, INVALID_CODES, isEdgeState, } from "./mutation.js";
+export { edgeChangeFor, nextDocument, resultingEdge, structuralRefusal, } from "./validity.js";
+export { anyPending, edgeStateOf, project } from "./write.js";
+export { sameList, sameValue } from "./equality.js";
+export { diffOrder, } from "./change.js";
+export { createStore, } from "./store.js";
+export { createMemorySource } from "./adapters/memory.js";
+export { createScriptedSource, } from "./adapters/scripted.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAQL,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAOL,WAAW,EACX,aAAa,EACb,WAAW,GACZ,MAAM,eAAe,CAAC;AAWvB,OAAO,EAEL,aAAa,EACb,YAAY,EACZ,aAAa,EACb,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAwC,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEpG,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,EAKL,SAAS,GACV,MAAM,aAAa,CAAC;AAErB,OAAO,EAQL,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAqB,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAIL,oBAAoB,GACrB,MAAM,wBAAwB,CAAC"}

package/dist/model.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The document this store holds, and the identity rule for an edge in it.
+ *
+ * The shapes here are the *store's* schema, not a tracker's: an adapter maps its
+ * own issues onto these and the store never learns what it mapped from. That is
+ * the whole of BYO-DataSource on this side of the port.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+import { type EdgeField, type Priority } from '@issuegraph/core';
+/**
+ * An issue reference, exactly as the adapter emits it.
+ *
+ * The specification admits two forms — a bare integer and the qualified
+ * `owner/repo#123` (§4.2) — and normalising between them is the reader's job.
+ * This store therefore treats a reference as an OPAQUE identity: it compares
+ * references, and it never parses, reformats or resolves one. An adapter's
+ * contract is that equal references mean the same issue.
+ */
+export type IssueRef = string;
+/** A relationship kind. The format's vocabulary, taken from the shared package. */
+export type EdgeKind = EdgeField;
+/**
+ * An edge's identity, derived from its content by {@link edgeId} rather than
+ * assigned by a host.
+ *
+ * Derived because the store has to recognise the edge an adapter returns as the
+ * same edge it drew optimistically. A host-assigned identifier would push that
+ * correlation onto every adapter, and an adapter that got it wrong would leave
+ * an optimistic edge stranded beside its own landed twin.
+ */
+export type EdgeId = string;
+/** Whether an issue is still open. Readiness (§6.2) is the deriver's to compute. */
+export type IssueState = 'open' | 'closed';
+/**
+ * One issue, reduced to what a relationship surface renders.
+ *
+ * `priority` is the *declared* priority (§4.3.5) as the adapter resolved it —
+ * the tracker's own convention where one exists, the frontmatter field where it
+ * does not. Resolving that precedence is the adapter's job, not the store's.
+ */
+export interface StoredIssue {
+    readonly ref: IssueRef;
+    readonly title: string;
+    readonly state: IssueState;
+    readonly priority?: Priority;
+    readonly url?: string;
+}
+/**
+ * One relationship, held as a directed pair even for the symmetric kinds.
+ *
+ * The pair is retained rather than normalised away because a symmetric edge is
+ * still *written* on one issue pointing at another (§4.3.4), and an editor has
+ * to know which issue carries the field in order to delete it. Symmetry is
+ * expressed in {@link edgeId} instead, so `A serialize-with B` and
+ * `B serialize-with A` are one edge without either of them losing its carrier.
+ */
+export interface StoredEdge {
+    readonly id: EdgeId;
+    readonly kind: EdgeKind;
+    readonly from: IssueRef;
+    readonly to: IssueRef;
+}
+/** Everything the store holds about the backlog at one instant. */
+export interface GraphDocument {
+    readonly issues: readonly StoredIssue[];
+    readonly edges: readonly StoredEdge[];
+}
+/**
+ * The identity of an edge, as a pure function of its content.
+ *
+ * References are percent-encoded before joining, so the separator cannot appear
+ * inside a reference: `encodeURIComponent` escapes `|`, which means no reference
+ * — however a tracker spells it — can forge the identity of a different edge.
+ *
+ * The two symmetric kinds (§4.3.4, §4.3.7) sort their endpoints, so the two
+ * spellings of one relationship collapse to one identity. The directed kinds do
+ * not, because for them the direction IS the fact: `A blocked-by B` and
+ * `B blocked-by A` are opposite claims about which issue may start.
+ */
+export declare function edgeId(kind: EdgeKind, from: IssueRef, to: IssueRef): EdgeId;
+/** An edge with its identity filled in from its content. */
+export declare function makeEdge(kind: EdgeKind, from: IssueRef, to: IssueRef): StoredEdge;
+/** The edge carrying an identity, or `undefined` when the document has none. */
+export declare function findEdge(document: GraphDocument, id: EdgeId): StoredEdge | undefined;
+/** Whether the document holds an issue under this reference. */
+export declare function hasIssue(document: GraphDocument, ref: IssueRef): boolean;
+/**
+ * Whether two edge lists state the same set of relationships, carriers included.
+ *
+ * Compared as a SET, not a sequence: an adapter is free to return its edges in
+ * whatever order its own storage yields, and treating a reordering as a change
+ * would re-derive the order and emit a change summary for a write that moved
+ * nothing.
+ *
+ * IDENTITY IS NOT ENOUGH, and the exception is the symmetric kinds. Their two
+ * spellings share one identity by design, but `StoredEdge` deliberately keeps
+ * the directed pair, because that pair is the field an editor deletes and the
+ * endpoints a retype to a directed kind inherits. Compare on identity alone and
+ * a rehydrate that reverses the carrier reads as "nothing changed" — after
+ * which a retype writes the OPPOSITE direction, which §17b names as the most
+ * common encoding mistake there is.
+ */
+export declare function sameEdgeSet(a: readonly StoredEdge[], b: readonly StoredEdge[]): boolean;
+//# sourceMappingURL=model.d.ts.map

package/dist/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAwB,MAAM,kBAAkB,CAAC;AAEvF;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B,mFAAmF;AACnF,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC;AAEjC;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B,oFAAoF;AACpF,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;CACvB;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,GAAG,MAAM,CAG3E;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,GAAG,UAAU,CAEjF;AAED,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEpF;AAED,gEAAgE;AAChE,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAExE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,UAAU,EAAE,EAAE,CAAC,EAAE,SAAS,UAAU,EAAE,GAAG,OAAO,CAOvF"}

package/dist/model.js

@@ -0,0 +1,64 @@
+/**
+ * The document this store holds, and the identity rule for an edge in it.
+ *
+ * The shapes here are the *store's* schema, not a tracker's: an adapter maps its
+ * own issues onto these and the store never learns what it mapped from. That is
+ * the whole of BYO-DataSource on this side of the port.
+ *
+ * @see https://github.com/autnmy/issuegraph/blob/main/SPEC.md
+ */
+import { isSymmetricEdgeField } from '@issuegraph/core';
+/**
+ * The identity of an edge, as a pure function of its content.
+ *
+ * References are percent-encoded before joining, so the separator cannot appear
+ * inside a reference: `encodeURIComponent` escapes `|`, which means no reference
+ * — however a tracker spells it — can forge the identity of a different edge.
+ *
+ * The two symmetric kinds (§4.3.4, §4.3.7) sort their endpoints, so the two
+ * spellings of one relationship collapse to one identity. The directed kinds do
+ * not, because for them the direction IS the fact: `A blocked-by B` and
+ * `B blocked-by A` are opposite claims about which issue may start.
+ */
+export function edgeId(kind, from, to) {
+    const [first, second] = isSymmetricEdgeField(kind) && to < from ? [to, from] : [from, to];
+    return `${kind}|${encodeURIComponent(first)}|${encodeURIComponent(second)}`;
+}
+/** An edge with its identity filled in from its content. */
+export function makeEdge(kind, from, to) {
+    return { id: edgeId(kind, from, to), kind, from, to };
+}
+/** The edge carrying an identity, or `undefined` when the document has none. */
+export function findEdge(document, id) {
+    return document.edges.find((edge) => edge.id === id);
+}
+/** Whether the document holds an issue under this reference. */
+export function hasIssue(document, ref) {
+    return document.issues.some((issue) => issue.ref === ref);
+}
+/**
+ * Whether two edge lists state the same set of relationships, carriers included.
+ *
+ * Compared as a SET, not a sequence: an adapter is free to return its edges in
+ * whatever order its own storage yields, and treating a reordering as a change
+ * would re-derive the order and emit a change summary for a write that moved
+ * nothing.
+ *
+ * IDENTITY IS NOT ENOUGH, and the exception is the symmetric kinds. Their two
+ * spellings share one identity by design, but `StoredEdge` deliberately keeps
+ * the directed pair, because that pair is the field an editor deletes and the
+ * endpoints a retype to a directed kind inherits. Compare on identity alone and
+ * a rehydrate that reverses the carrier reads as "nothing changed" — after
+ * which a retype writes the OPPOSITE direction, which §17b names as the most
+ * common encoding mistake there is.
+ */
+export function sameEdgeSet(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const byId = new Map(a.map((edge) => [edge.id, edge]));
+    return b.every((edge) => {
+        const other = byId.get(edge.id);
+        return other !== undefined && other.from === edge.from && other.to === edge.to;
+    });
+}
+//# sourceMappingURL=model.js.map

package/dist/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAiC,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAmEvF;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,MAAM,CAAC,IAAc,EAAE,IAAc,EAAE,EAAY;IACjE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,oBAAoB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAC1F,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;AAC9E,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,QAAQ,CAAC,IAAc,EAAE,IAAc,EAAE,EAAY;IACnE,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;AACxD,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,QAAQ,CAAC,QAAuB,EAAE,EAAU;IAC1D,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACvD,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,QAAQ,CAAC,QAAuB,EAAE,GAAa;IAC7D,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CAAC,CAAwB,EAAE,CAAwB;IAC5E,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IACxC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACvD,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE;QACtB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChC,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;IACjF,CAAC,CAAC,CAAC;AACL,CAAC"}