cursedbelt 0.0.0 → 2.3.0

package/dist/core/analytics/schedule.js

@@ -0,0 +1,373 @@
+/**
+ * "How long until this queue is empty, and does another worker actually help?"
+ *
+ * ── The question this exists to answer (owner, 2026-08-23) ───────────────────
+ * *"For estimates of how long to empty tasks I would also like to be able to see
+ * them based on if I added to the fleet size or reduced it… I want to be able to
+ * tell whether there is a point where adding to the fleet slows down more than
+ * it speeds up. I also want to see the expected token usage so I know if I run
+ * out of tokens earlier and how much earlier."*
+ *
+ * Three separate claims hide in that, and a `remaining / rate` division answers
+ * none of them:
+ *
+ * 1. **Work does not parallelise freely.** Two tasks that write the same files
+ *    may not run together whatever the fleet size — that is the orchestrator's
+ *    own scope rule, and it is why a queue of ten tasks all scoped to one app
+ *    drains at exactly the same speed with eight workers as with one.
+ * 2. **Workers are not free of each other.** This machine's own measurements say
+ *    a verify gate takes 2m09s idle and 857s (6.6x) under seventeen concurrent
+ *    gates. Past some point another worker makes *everyone* slower, so the
+ *    makespan curve turns back UP — the "point where adding to the fleet slows
+ *    down more than it speeds up" is real, has a number, and this module finds
+ *    it. A scheduler with no contention term can never report one, because pure
+ *    list scheduling is monotone: more workers is never worse.
+ * 3. **Tokens are spent by work, not by time.** Doubling the fleet does not
+ *    double the tokens a queue costs — it spends the same budget roughly twice
+ *    as fast, so the wall-clock moment you run dry arrives sooner even though the
+ *    total is unchanged. Both numbers matter and they move in opposite
+ *    directions.
+ *
+ * ── Why it lives in cursedbelt and not in the orchestrator ───────────────────
+ * Nothing here knows what a "task" is. It schedules ITEMS with durations,
+ * exclusion keys and dependencies over WORKERS, which is the same shape as a
+ * deploy train, a batch of renders, a backup rotation or a CI matrix. The
+ * orchestrator supplies the meaning (a scope string, a serial group, a tier's
+ * measured duration) and reads the answer back; any other dashboard in the fleet
+ * can do the same without re-deriving a scheduler.
+ *
+ * Pure, deterministic, and clock-free: the caller passes `now` when it wants
+ * absolute times. That is what lets the whole forecast be asserted in a test
+ * rather than eyeballed on a chart.
+ */
+/** No contention at all — the ideal machine. Useful as a comparison line, and as
+ *  the honest choice when the work is not CPU-bound on one host. */
+export const NO_CONTENTION = { freeLanes: Number.POSITIVE_INFINITY, slowdownPerExtraWorker: 0 };
+export function stretchAt(model, concurrency) {
+    if (concurrency <= model.freeLanes)
+        return 1;
+    const raw = 1 + model.slowdownPerExtraWorker * (concurrency - model.freeLanes);
+    return Math.min(raw, model.maxStretch ?? 8);
+}
+/**
+ * Event-driven list scheduling with resource exclusion and a contention term.
+ *
+ * The loop is: admit everything that can start, advance the clock to whichever
+ * running item finishes FIRST **at the current concurrency's speed**, retire it,
+ * repeat. Progress is tracked as remaining WORK rather than an end timestamp,
+ * which is what makes contention correct rather than decorative: a task that
+ * started alone and is joined by three others slows down for the rest of its run
+ * and not retroactively.
+ *
+ * Admission order is priority, then longest-first. Longest-first (LPT) is the
+ * classic list-scheduling heuristic and matters here: shortest-first leaves a
+ * multi-hour task to start last and stretches the makespan by most of its own
+ * length, which would make every large fleet look pointless.
+ */
+export function simulateSchedule(items, options) {
+    const workers = Math.max(1, Math.floor(options.workers));
+    const contention = options.contention ?? NO_CONTENTION;
+    const startAt = options.startAt ?? 0;
+    const maxEvents = options.maxEvents ?? 20_000;
+    const pending = [...items].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0) || b.durationMs - a.durationMs);
+    const live = [];
+    const done = new Set();
+    const timeline = [];
+    const known = new Set(items.map((i) => i.id));
+    // Items already in flight occupy workers from t=0 and block their scopes.
+    for (const item of pending.filter((i) => typeof i.runningRemainingMs === 'number')) {
+        live.push({ item, remainingMs: Math.max(0, item.runningRemainingMs), startAt: 0, effectiveMs: 0 });
+    }
+    let queue = pending.filter((i) => typeof i.runningRemainingMs !== 'number');
+    let t = 0;
+    let peak = live.length;
+    // Area under the concurrency curve, for the time-weighted mean.
+    let concurrencyArea = 0;
+    let events = 0;
+    const conflicts = (candidate) => live.some((l) => blocks(candidate, l.item));
+    const depsMet = (candidate) => (candidate.dependsOn ?? []).every((id) => done.has(id) || !known.has(id));
+    while ((queue.length > 0 || live.length > 0) && events++ < maxEvents) {
+        // ── Admit ────────────────────────────────────────────────────────────────
+        let admitted = true;
+        while (admitted && live.length < workers) {
+            admitted = false;
+            for (let i = 0; i < queue.length; i++) {
+                const candidate = queue[i];
+                if (!depsMet(candidate) || conflicts(candidate))
+                    continue;
+                queue.splice(i, 1);
+                live.push({
+                    item: candidate,
+                    remainingMs: candidate.durationMs,
+                    startAt: t,
+                    effectiveMs: 0,
+                });
+                admitted = true;
+                break;
+            }
+        }
+        if (live.length > peak)
+            peak = live.length;
+        if (live.length === 0)
+            break; // everything left is unschedulable
+        // ── Advance ──────────────────────────────────────────────────────────────
+        // Everyone runs at the same rate, so the first to finish is simply the one
+        // with the least work left.
+        const stretch = stretchAt(contention, live.length);
+        const slice = Math.min(...live.map((l) => l.remainingMs)) * stretch;
+        // A zero-duration item would otherwise spin the loop without advancing.
+        const step = slice > 0 ? slice : 0;
+        const work = step / stretch;
+        for (const l of live) {
+            l.remainingMs -= work;
+            l.effectiveMs += step;
+        }
+        concurrencyArea += live.length * step;
+        t += step;
+        // ── Retire ───────────────────────────────────────────────────────────────
+        for (let i = live.length - 1; i >= 0; i--) {
+            // Floating-point: `remainingMs` lands on ~1e-10 rather than exactly 0.
+            if (live[i].remainingMs > 1e-6)
+                continue;
+            const l = live[i];
+            live.splice(i, 1);
+            done.add(l.item.id);
+            timeline.push({
+                id: l.item.id,
+                startAt: startAt + l.startAt,
+                endAt: startAt + t,
+                durationMs: l.item.durationMs,
+                effectiveMs: l.effectiveMs,
+                waitedMs: l.startAt,
+                blockedBy: l.startAt === 0 ? null : whyWaited(l.item, timeline, known),
+            });
+        }
+    }
+    const workMs = items.reduce((s, i) => s + (i.runningRemainingMs ?? i.durationMs), 0);
+    const spentMs = timeline.reduce((s, r) => s + r.effectiveMs, 0);
+    const makespanMs = t;
+    return {
+        workers,
+        makespanMs,
+        workMs,
+        spentMs,
+        contentionMs: Math.max(0, spentMs - timeline.reduce((s, r) => s + r.durationMs, 0)),
+        utilization: makespanMs === 0 ? 0 : clamp01(workMs / (workers * makespanMs)),
+        avgConcurrency: makespanMs === 0 ? 0 : round2(concurrencyArea / makespanMs),
+        peakConcurrency: peak,
+        cost: items.reduce((s, i) => s + (i.cost ?? 0), 0),
+        timeline: timeline.sort((a, b) => a.startAt - b.startAt),
+        unschedulable: queue.map((i) => i.id),
+    };
+}
+/** May `candidate` NOT run beside `other`? */
+function blocks(candidate, other) {
+    if (candidate.id === other.id)
+        return true;
+    if (candidate.group != null && candidate.group === other.group)
+        return true;
+    const mine = candidate.exclusive ?? [];
+    const theirs = other.exclusive ?? [];
+    if (mine.length === 0 || theirs.length === 0)
+        return false;
+    // `*` is the wildcard the orchestrator uses for fleet-wide work: it conflicts
+    // with everything that declares anything.
+    if (mine.includes('*') || theirs.includes('*'))
+        return true;
+    return mine.some((s) => theirs.includes(s));
+}
+/**
+ * A best-effort reason an item started late — for the table behind the chart.
+ *
+ * Deliberately approximate and labelled as such: the precise answer would need
+ * the admission loop to record every refusal at every event, which is a lot of
+ * bookkeeping for a column. "Was it waiting on a dependency, on a conflicting
+ * neighbour, or simply for a free worker" is the distinction a reader acts on,
+ * and that is decidable from the item alone.
+ */
+function whyWaited(item, _timeline, known) {
+    if ((item.dependsOn ?? []).some((id) => known.has(id)))
+        return 'dependency';
+    if ((item.exclusive?.length ?? 0) > 0 || item.group != null)
+        return 'conflict';
+    return 'worker';
+}
+export function sweepFleetSizes(items, options = {}) {
+    const maxWorkers = Math.max(1, Math.floor(options.maxWorkers ?? 8));
+    const tolerance = options.tolerance ?? 0.05;
+    const results = [];
+    for (let w = 1; w <= maxWorkers; w++) {
+        results.push(simulateSchedule(items, { ...options, workers: w }));
+    }
+    const base = results[0].makespanMs;
+    const points = results.map((r, i) => ({
+        workers: r.workers,
+        makespanMs: Math.round(r.makespanMs),
+        speedup: r.makespanMs === 0 ? 1 : round2(base / r.makespanMs),
+        efficiency: r.makespanMs === 0 ? 1 : round2(base / r.makespanMs / r.workers),
+        marginalMs: Math.round(i === 0 ? 0 : results[i - 1].makespanMs - r.makespanMs),
+        utilization: r.utilization,
+        avgConcurrency: r.avgConcurrency,
+        peakConcurrency: r.peakConcurrency,
+        contentionMs: Math.round(r.contentionMs),
+        cost: r.cost,
+        burnPerHour: r.makespanMs === 0 ? 0 : Math.round((r.cost / r.makespanMs) * 3_600_000),
+        unschedulable: r.unschedulable.length,
+    }));
+    // 🔴 The SMALLEST fleet that is as good as it gets — not the fastest, and not
+    // the last one with a positive margin. See `sweetSpot`'s doc for the measured
+    // case where the marginal reading recommends four times too many workers.
+    const best = Math.min(...points.map((p) => p.makespanMs));
+    const sweetSpot = points.find((p) => p.makespanMs <= best * (1 + tolerance))?.workers ?? 1;
+    const worse = points.find((p) => p.workers > 1 && p.marginalMs < 0);
+    return {
+        points,
+        sweetSpot,
+        turnsNegativeAt: worse ? worse.workers : null,
+        parallelismCeiling: Math.max(...results.map((r) => r.peakConcurrency), 1),
+    };
+}
+/**
+ * When a spend budget runs out at each fleet size.
+ *
+ * The counter-intuitive half, and the reason the owner asked for it: **the total
+ * is the same and the deadline is not.** A queue that costs 40M tokens costs 40M
+ * whether one agent or five works it; five agents simply reach the wall in a
+ * fifth of the time. So `coverage` (do I have enough at all?) is flat across the
+ * sweep while `exhaustedInMs` shrinks — and the honest reading is "more workers
+ * does not cost more, it costs sooner".
+ */
+export function projectBudget(sweep, budget) {
+    return sweep.points.map((p) => {
+        const coverage = p.cost === 0 ? 1 : clamp01(budget / p.cost);
+        return {
+            workers: p.workers,
+            exhaustedInMs: p.burnPerHour <= 0 || budget >= p.cost ? null : Math.round((budget / p.burnPerHour) * 3_600_000),
+            coverage: round2(coverage),
+            shortfall: Math.max(0, p.cost - budget),
+            burnPerHour: p.burnPerHour,
+        };
+    });
+}
+/**
+ * Fit a {@link ContentionModel} to runs that actually happened.
+ *
+ * Deliberately a two-group comparison rather than a regression: the sample is a
+ * few hundred runs of wildly different work, so a least-squares line through
+ * duration-versus-concurrency mostly measures which KIND of task tends to run
+ * alone. Comparing the median duration of "ran near-alone" against the median of
+ * "ran in a crowd" is coarse, robust, and explainable on a caveat line, which is
+ * what a number a fleet-size decision rests on has to be.
+ *
+ * Returns `null` when either group is too thin to speak — the caller must then
+ * say the model is assumed, not measured.
+ */
+export function estimateContention(samples, options = {}) {
+    const freeLanes = options.freeLanes ?? 2;
+    const minGroup = options.minGroup ?? 5;
+    const quiet = samples.filter((s) => s.concurrency <= freeLanes).map((s) => s.durationMs);
+    const busy = samples.filter((s) => s.concurrency > freeLanes);
+    if (quiet.length < minGroup || busy.length < minGroup)
+        return null;
+    const quietMedian = medianOf(quiet);
+    const busyMedian = medianOf(busy.map((s) => s.durationMs));
+    if (quietMedian <= 0)
+        return null;
+    const excess = medianOf(busy.map((s) => s.concurrency)) - freeLanes;
+    if (excess <= 0)
+        return null;
+    const stretch = busyMedian / quietMedian;
+    // A stretch below 1 means the crowded runs were FASTER — real, and it means
+    // the sample is dominated by task mix rather than by load. Report no
+    // measurable contention rather than a negative slowdown, which would make the
+    // simulator recommend an unbounded fleet.
+    const slope = Math.max(0, (stretch - 1) / excess);
+    return { freeLanes, slowdownPerExtraWorker: round2(slope), maxStretch: 8 };
+}
+/**
+ * Turn a set of intervals into the step function of how many were live.
+ *
+ * The exact series behind an "average tasks at once" number, so a reader can see
+ * the overlaps that produced it instead of taking the mean on faith. Ends before
+ * starts at a tie: two runs where one finishes as the next begins were never
+ * simultaneous, and counting them as two reports a concurrency the fleet's own
+ * limit forbids.
+ */
+export function concurrencyProfile(intervals) {
+    const points = [];
+    for (const i of intervals) {
+        if (i.to <= i.from)
+            continue;
+        points.push({ at: i.from, d: 1 }, { at: i.to, d: -1 });
+    }
+    points.sort((a, b) => a.at - b.at || a.d - b.d);
+    const out = [];
+    let live = 0;
+    for (const p of points) {
+        live += p.d;
+        const last = out[out.length - 1];
+        if (last && last.at === p.at)
+            last.count = live;
+        else
+            out.push({ at: p.at, count: live });
+    }
+    return out;
+}
+/**
+ * Time-weighted mean concurrency across `[from, to)`, optionally counting only
+ * the parts of the window the fleet was actually ELIGIBLE to work.
+ *
+ * 🔴 The `exclude` argument is the whole point (owner report, 2026-08-23: *"the
+ * Tasks at once card says '.2'… if it is using paused time to calculate that
+ * there were usually 0 tasks at once let's stop letting it do that"*). Averaging
+ * a running fleet over a window it was switched off for 90% of does not describe
+ * the fleet, it describes the switch — and it reports a busy afternoon as 0.2.
+ * Excluded spans are removed from BOTH the numerator and the denominator, so the
+ * answer is "while it was running, this many at once".
+ */
+export function meanConcurrency(intervals, window, exclude = []) {
+    const width = liveWidth(window, exclude);
+    if (width <= 0)
+        return 0;
+    let area = 0;
+    for (const i of intervals) {
+        const from = Math.max(i.from, window.from);
+        const to = Math.min(i.to, window.to);
+        if (to <= from)
+            continue;
+        area += liveWidth({ from, to }, exclude);
+    }
+    return round2(area / width);
+}
+/** Width of `window` minus everything `exclude` covers. Overlapping excludes are
+ *  merged first, or a nested pause subtracts twice and the mean explodes. */
+function liveWidth(window, exclude) {
+    const total = Math.max(0, window.to - window.from);
+    if (total === 0 || exclude.length === 0)
+        return total;
+    const clipped = exclude
+        .map((e) => ({ from: Math.max(e.from, window.from), to: Math.min(e.to, window.to) }))
+        .filter((e) => e.to > e.from)
+        .sort((a, b) => a.from - b.from);
+    let covered = 0;
+    let cursor = -Infinity;
+    for (const e of clipped) {
+        const from = Math.max(e.from, cursor);
+        if (e.to > from) {
+            covered += e.to - from;
+            cursor = e.to;
+        }
+    }
+    return Math.max(0, total - covered);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+const clamp01 = (n) => Math.max(0, Math.min(1, n));
+const round2 = (n) => Math.round(n * 100) / 100;
+function medianOf(values) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+//# sourceMappingURL=schedule.js.map

package/dist/core/analytics/schedule.js.map

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

package/dist/core/category/index.d.ts

@@ -0,0 +1,4 @@
+export type { Category, CategoryCreateInput, CategoryNode, CategoryStore, } from './types';
+export { buildCategoryForest, categoryPath, descendantCategoryIds, flattenCategoryForest, wouldCreateCycle, } from './tree';
+export { createMemoryCategoryStore } from './memoryStore';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/category/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/category/index.ts"],"names":[],"mappings":"AAKA,YAAY,EACV,QAAQ,EACR,mBAAmB,EACnB,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC"}

package/dist/core/category/index.js

@@ -0,0 +1,7 @@
+// src/core/category — reusable hierarchical category/folder model, reaching consumers
+// through `cursedbelt/react`'s categoryTree. Pure and
+// React-free (the `TreeView` adapter lives in `cursedbelt/react`), so servers
+// can import the contract + store without pulling any UI runtime.
+export { buildCategoryForest, categoryPath, descendantCategoryIds, flattenCategoryForest, wouldCreateCycle, } from './tree';
+export { createMemoryCategoryStore } from './memoryStore';
+//# sourceMappingURL=index.js.map

package/dist/core/category/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/category/index.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,sDAAsD;AACtD,8EAA8E;AAC9E,kEAAkE;AAQlE,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC"}

package/dist/core/category/memoryStore.d.ts

@@ -0,0 +1,22 @@
+import type { Category, CategoryCreateInput } from './types';
+/**
+ * Zero-config in-memory {@link CategoryStore}: a per-boot `Map` per tenant, so a
+ * host that wires nothing up still gets a working (non-persistent) category
+ * tree — the same role `createMemoryNotesStore`/`createMemoryAuditSink` play.
+ * Swap in a persistent store (f's `createSqliteCategoryStore`) for real data.
+ *
+ * Deliberately not annotated `: CategoryStore` — the interface allows async
+ * returns, which would force callers (and these tests) to `await` values that
+ * are always synchronous here. Structural typing keeps it assignable wherever a
+ * `CategoryStore` is expected.
+ */
+export declare function createMemoryCategoryStore(idFactory?: () => string): {
+    list(tenant: string): Category[];
+    create(tenant: string, input: CategoryCreateInput): Category;
+    rename(tenant: string, id: string, label: string): Category;
+    move(tenant: string, id: string, parentId: string | null, order?: number): Category;
+    /** Remove a category, promoting its direct children to the removed node's
+     * own parent so no subtree is orphaned. */
+    remove(tenant: string, id: string): void;
+};
+//# sourceMappingURL=memoryStore.d.ts.map

package/dist/core/category/memoryStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryStore.d.ts","sourceRoot":"","sources":["../../../src/core/category/memoryStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAiB,MAAM,SAAS,CAAC;AAG5E;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,GAAE,MAAM,MAAkC;iBA4B5E,MAAM,GAAG,QAAQ,EAAE;mBAIjB,MAAM,SAAS,mBAAmB,GAAG,QAAQ;mBAiB7C,MAAM,MAAM,MAAM,SAAS,MAAM,GAAG,QAAQ;iBAQ9C,MAAM,MAAM,MAAM,YAAY,MAAM,GAAG,IAAI,UAAU,MAAM,GAAG,QAAQ;IAkBnF;+CAC2C;mBAC5B,MAAM,MAAM,MAAM,GAAG,IAAI;EAY3C"}

package/dist/core/category/memoryStore.js

@@ -0,0 +1,98 @@
+import { wouldCreateCycle } from './tree';
+/**
+ * Zero-config in-memory {@link CategoryStore}: a per-boot `Map` per tenant, so a
+ * host that wires nothing up still gets a working (non-persistent) category
+ * tree — the same role `createMemoryNotesStore`/`createMemoryAuditSink` play.
+ * Swap in a persistent store (f's `createSqliteCategoryStore`) for real data.
+ *
+ * Deliberately not annotated `: CategoryStore` — the interface allows async
+ * returns, which would force callers (and these tests) to `await` values that
+ * are always synchronous here. Structural typing keeps it assignable wherever a
+ * `CategoryStore` is expected.
+ */
+export function createMemoryCategoryStore(idFactory = () => crypto.randomUUID()) {
+    const byTenant = new Map();
+    const tenantMap = (tenant) => {
+        let map = byTenant.get(tenant);
+        if (!map) {
+            map = new Map();
+            byTenant.set(tenant, map);
+        }
+        return map;
+    };
+    const requireCategory = (map, id) => {
+        const cat = map.get(id);
+        if (!cat)
+            throw new Error(`no category with id ${id}`);
+        return cat;
+    };
+    /** Next order value at a level = max sibling order + 1 (append to the end). */
+    const nextOrder = (map, parentId) => {
+        let max = -1;
+        for (const c of map.values()) {
+            if (c.parentId === parentId && c.order > max)
+                max = c.order;
+        }
+        return max + 1;
+    };
+    return {
+        list(tenant) {
+            return [...tenantMap(tenant).values()];
+        },
+        create(tenant, input) {
+            const map = tenantMap(tenant);
+            const parentId = input.parentId ?? null;
+            if (parentId !== null && !map.has(parentId)) {
+                throw new Error(`no parent category with id ${parentId}`);
+            }
+            const category = {
+                id: idFactory(),
+                parentId,
+                label: input.label,
+                order: input.order ?? nextOrder(map, parentId),
+                tenant,
+            };
+            map.set(category.id, category);
+            return category;
+        },
+        rename(tenant, id, label) {
+            const map = tenantMap(tenant);
+            const cat = requireCategory(map, id);
+            const updated = { ...cat, label };
+            map.set(id, updated);
+            return updated;
+        },
+        move(tenant, id, parentId, order) {
+            const map = tenantMap(tenant);
+            const cat = requireCategory(map, id);
+            if (parentId !== null && !map.has(parentId)) {
+                throw new Error(`no parent category with id ${parentId}`);
+            }
+            if (wouldCreateCycle([...map.values()], id, parentId)) {
+                throw new Error(`moving ${id} under ${parentId} would create a cycle`);
+            }
+            const updated = {
+                ...cat,
+                parentId,
+                order: order ?? nextOrder(map, parentId),
+            };
+            map.set(id, updated);
+            return updated;
+        },
+        /** Remove a category, promoting its direct children to the removed node's
+         * own parent so no subtree is orphaned. */
+        remove(tenant, id) {
+            const map = tenantMap(tenant);
+            const cat = map.get(id);
+            if (!cat)
+                return;
+            for (const child of map.values()) {
+                if (child.parentId === id) {
+                    map.set(child.id, { ...child, parentId: cat.parentId });
+                }
+            }
+            map.delete(id);
+        },
+    };
+}
+//# sourceMappingURL=memoryStore.js.map

package/dist/core/category/memoryStore.js.map

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

package/dist/core/category/tree.d.ts

@@ -0,0 +1,27 @@
+import type { Category, CategoryNode } from './types';
+/**
+ * Would setting `childId`'s parent to `candidateParentId` create a cycle?
+ * True when the candidate parent is the child itself or one of its
+ * descendants — i.e. walking UP from the candidate reaches the child.
+ */
+export declare function wouldCreateCycle(cats: Category[], childId: string, candidateParentId: string | null): boolean;
+/**
+ * Assemble a flat category list into a sorted forest of {@link CategoryNode}s.
+ * Defensive by construction — a category is treated as a root when its
+ * `parentId` is `null`, points at a missing category (orphan), or would form a
+ * cycle. So malformed data never loses a node or infinite-loops; every input
+ * category appears exactly once in the output.
+ */
+export declare function buildCategoryForest(cats: Category[]): CategoryNode[];
+/** Flatten a forest into pre-order (parent before its children), preserving the
+ * sibling ordering {@link buildCategoryForest} established. */
+export declare function flattenCategoryForest(forest: CategoryNode[]): CategoryNode[];
+/**
+ * The root→node breadcrumb path for `id` (inclusive), or `[]` when the id is
+ * unknown. Cycle-safe — stops if the parent chain ever revisits a node.
+ */
+export declare function categoryPath(cats: Category[], id: string): Category[];
+/** Every descendant id of `id` (excluding `id` itself), depth-first. Used by a
+ * store's `remove`/`move` to reason about a subtree. */
+export declare function descendantCategoryIds(cats: Category[], id: string): string[];
+//# sourceMappingURL=tree.d.ts.map

package/dist/core/category/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../../src/core/category/tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAOtD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,EAAE,EAChB,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAaT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAsBpE;AAED;+DAC+D;AAC/D,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAU5E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,EAAE,CAarE;AAED;wDACwD;AACxD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAoB5E"}