looply-cli 0.0.0-stage → 0.2.0

package/dist/goal-ownership.js

@@ -0,0 +1,576 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopedQueue = scopedQueue;
+exports.resolveGoalBinding = resolveGoalBinding;
+exports.splitGoalWork = splitGoalWork;
+exports.currentCompilerPlanExists = currentCompilerPlanExists;
+exports.currentPlanRevision = currentPlanRevision;
+exports.decideCompile = decideCompile;
+exports.contradictingItems = contradictingItems;
+exports.stillTheAuthority = stillTheAuthority;
+exports.materialiseGoalPlan = materialiseGoalPlan;
+exports.adoptGoalItems = adoptGoalItems;
+exports.releaseGoalItems = releaseGoalItems;
+exports.nodeGoalReleaser = nodeGoalReleaser;
+const core_1 = require("@looply/core");
+const goal_compile_1 = require("./goal-compile");
+const queue_store_1 = require("./queue-store");
+/**
+ * The same queue, showing only what this run owns.
+ *
+ * `list()` is filtered and NOTHING else is. That asymmetry is the whole design:
+ * `list()` is how work is chosen, so scoping it is what stops two runs picking
+ * the same item — but `get()` and `update()` are how work already in hand is
+ * read back and written, and scoping those would make a run unable to finish an
+ * item whose ownership changed underneath it. A run that cannot write down what
+ * it just did is worse than one that sees an item it will not pick.
+ *
+ * The filter is symmetric: a goal run sees only its own items, and an unbound
+ * run sees only unowned ones. The second half matters as much as the first —
+ * without it, a hand-typed `looply run` would quietly pick up work a goal is in
+ * the middle of.
+ */
+function scopedQueue(queue, scope) {
+    if (scope === null) {
+        // Still wrapped, not returned as-is: an unbound run must be hidden from
+        // goal-owned work too, and returning the raw store here is exactly the
+        // asymmetry that would leave one direction unguarded.
+        return {
+            list: () => queue.list().filter((i) => (0, core_1.isEligibleFor)(i, null)),
+            get: (id) => queue.get(id),
+            update: (id, v, patch) => queue.update(id, v, patch),
+        };
+    }
+    return {
+        list: () => queue.list().filter((i) => (0, core_1.isEligibleFor)(i, scope)),
+        get: (id) => queue.get(id),
+        update: (id, v, patch) => queue.update(id, v, patch),
+    };
+}
+/**
+ * Resolve the goal a Start named, refreshing the local mirror only if it must.
+ *
+ * The happy path is deliberately OFFLINE. The daemon pulls goals on its own
+ * cadence, so by the time it spawns a run the mirror almost always already
+ * holds the version the phone was looking at — and a run that phoned home
+ * before it could begin would make the server a dependency of doing any work at
+ * all, which is the opposite of what this product is.
+ *
+ * The version is what makes that safe. It is not a freshness heuristic: the
+ * server stamped it at the moment the command was created, so an exact match
+ * proves the mirror holds the very goal the person tapped Start on, whatever
+ * has happened since.
+ */
+async function resolveGoalBinding(deps) {
+    const { goalId, goalVersion, mirror, projectId } = deps;
+    if (goalId === undefined || goalVersion === undefined)
+        return { kind: 'unbound' };
+    const first = mirror.get(goalId);
+    if (first !== null) {
+        if (first.version === goalVersion)
+            return check(first, projectId);
+        if (first.version > goalVersion) {
+            // This machine is AHEAD of the Start. Goal versions only ever go up, so a
+            // command naming 7 against a mirror holding 8 is describing a past that
+            // cannot come back — and no server is needed to know it. Refused
+            // terminally rather than retried: the old answer was an hour of pointless
+            // three-second retries for a command that could never become current.
+            return {
+                kind: 'refused',
+                reason: `goal ${goalId} has moved on since that Start was made (version ${first.version}, not ${goalVersion}) — start it again`,
+                lapse: 'superseded',
+            };
+        }
+    }
+    // Not mirrored here, or mirrored BEHIND what the phone saw. Both are answered
+    // the same way: ask, once. Being behind is the machine's problem, not the
+    // command's, so it stays retryable.
+    if (!deps.refresh) {
+        return {
+            kind: 'retry',
+            reason: first === null
+                ? `goal ${goalId} is not known here yet, and this machine is not paired to ask`
+                : `goal ${goalId} is at version ${first.version} here but the phone saw ${goalVersion}, and this machine is not paired to ask`,
+        };
+    }
+    if ((await deps.refresh()) === 'unreachable') {
+        // Retryable, NOT refused. The next attempt may well reach the server, and
+        // turning a network blip into a dead command would lose the person's tap.
+        return { kind: 'retry', reason: `could not reach the server to check goal ${goalId}` };
+    }
+    const second = mirror.get(goalId);
+    if (second === null) {
+        // The server was asked and does not have it. Nothing about waiting will
+        // change that.
+        return { kind: 'refused', reason: `there is no goal ${goalId} in this project`, lapse: 'gone' };
+    }
+    if (second.version !== goalVersion) {
+        // The goal moved on between the tap and now. Acting on it would carry out
+        // an instruction against wording nobody approved, so the phone has to ask
+        // again with what it can now see.
+        return {
+            kind: 'refused',
+            reason: `goal ${goalId} has changed since that Start was made (version ${second.version}, not ${goalVersion}) — start it again`,
+            lapse: 'superseded',
+        };
+    }
+    return check(second, projectId);
+}
+function check(goal, projectId) {
+    if (goal.projectId !== projectId) {
+        // A mirror holding another project's goal is a paired-machine mix-up, not a
+        // transient one. Running it here would work this tree against a goal
+        // written about a different repository.
+        return { kind: 'refused', reason: `goal ${goal.id} belongs to another project`, lapse: 'gone' };
+    }
+    if (goal.state !== 'active') {
+        // Version match and state are independent: a goal can be abandoned without
+        // its wording changing, so the stamp alone does not prove it may run.
+        return {
+            kind: 'refused',
+            reason: `goal ${goal.id} is ${goal.state} — only an active goal can be worked on`,
+            lapse: goal.state === 'abandoned' ? 'abandoned' : 'gone',
+        };
+    }
+    return { kind: 'bound', goal };
+}
+function splitGoalWork(items, scope) {
+    const split = {
+        currentPlan: [],
+        manual: [],
+        olderPlans: [],
+        unknownPlans: [],
+        forged: [],
+        newerPlans: [],
+    };
+    for (const item of items) {
+        switch ((0, core_1.classifyForScope)(item, scope)) {
+            case 'current-plan':
+                split.currentPlan.push(item);
+                break;
+            case 'manual':
+                split.manual.push(item);
+                break;
+            case 'older-plan':
+                split.olderPlans.push(item);
+                break;
+            case 'unknown-plan':
+                split.unknownPlans.push(item);
+                break;
+            case 'forged-provenance':
+                split.forged.push(item);
+                break;
+            case 'newer-plan':
+                split.newerPlans.push(item);
+                break;
+            /**
+             * REVISIONS BUCKET WITH THEIR VERSIONS, because they are the same facts
+             * one level down.
+             *
+             * These two cases used to fall through into nothing, which was harmless
+             * only while a run selected with a revision-BLIND scope — no item could
+             * ever classify as either. Making selection revision-aware turns that
+             * silence into a hole: an older revision would vanish from `olderPlans`
+             * and a newer one from `newerPlans`, so `decideCompile` would stop seeing
+             * the contradiction it exists to catch.
+             */
+            case 'older-revision':
+                split.olderPlans.push(item);
+                break;
+            case 'newer-revision':
+                split.newerPlans.push(item);
+                break;
+            case 'unowned':
+            case 'not-ours':
+                break;
+        }
+    }
+    return split;
+}
+/**
+ * Has the compiler already produced a plan for THIS version of this goal?
+ *
+ * Counts `current-plan` and nothing else. Not manual work, which a person
+ * provided rather than the compiler planning it; not an earlier plan, whose
+ * counting was the original defect; and not a provenance-unknown legacy item,
+ * because "some compiler once made this" is not evidence that THIS version has
+ * a plan — treating it as such would leave an amended goal unable to compile
+ * for ever, which is the same defect wearing a different hat.
+ *
+ * Existence, not usability: a finished current plan still exists, and that is
+ * what stops a second one being compiled for the same version.
+ */
+function currentCompilerPlanExists(items, scope) {
+    return splitGoalWork(items, scope).currentPlan.length > 0;
+}
+/**
+ * How many plans this goal version has had, read back off the queue.
+ *
+ * THE ONLY HOME THAT FAILS CLOSED, and the reason is that it is not a separate
+ * fact at all — it is a property of the rows themselves. queue.json has writers
+ * that do not hold the lease, so a stale one can rename its own snapshot over
+ * the file; but when it does, the revision number and the plan it counts go in
+ * the SAME rename. The next Start then sees the earlier revision and
+ * re-materialises that one, which is a retry. It can never see a later revision
+ * than the work that survives, so a clobber cannot skip a budget forward.
+ *
+ * Counted over the goal's own compiled rows at this VERSION, whatever revision
+ * they belong to — deliberately NOT through `scopedQueue`, which hides earlier
+ * revisions and would therefore forget they ever happened. `releaseOnAbandon`
+ * keeps `closed` rows owned, so the marker each revision leaves behind survives
+ * an abandonment that frees everything still workable.
+ *
+ * Zero means this version has had no plan yet. An absent revision reads as 1,
+ * which is what every plan compiled before revisions existed is.
+ */
+function currentPlanRevision(items, goalId, goalVersion) {
+    let highest = 0;
+    for (const item of items) {
+        if ((item.goalId ?? null) !== goalId)
+            continue;
+        if (item.source !== core_1.COMPILER_SOURCE)
+            continue;
+        if (item.compiledForGoalVersion !== goalVersion)
+            continue;
+        const revision = (0, core_1.planRevisionOf)(item);
+        if (revision > highest)
+            highest = revision;
+    }
+    return highest;
+}
+/**
+ * Should this run compile a plan for the goal version it is bound to?
+ *
+ * THE ONE AUTHORITY. It existed twice before — once in `run-cmd`, once
+ * re-implemented in the exercise that claims to prove `run-cmd` — and the two
+ * had already drifted apart: the copy used `nothing scoped-visible at all`,
+ * which answers CASE 7 (an older plan kept, the person's own work now finished,
+ * no plan for this version) with "do not compile" while the real composition
+ * root compiles. A test written against the copy would have proved the opposite
+ * of the behaviour it was named after and passed. Two predicates for one
+ * question is the defect; this is the fix, and the exercise now calls it.
+ *
+ * The order is the argument:
+ *
+ *   unbound         a run with no goal never compiles — there is no intent to
+ *                   compile FROM.
+ *   contradicted    the queue holds a plan for a LATER version, which is
+ *                   durable evidence this run's authority is stale. `run-cmd`
+ *                   refuses terminally before ever reaching here; this is the
+ *                   second lock, so that removing the first cannot silently
+ *                   turn a contradiction into a fresh plan.
+ *   plan-exists     this version has already had one. EXISTENCE, not progress:
+ *                   a finished or stalled plan still counts, and that is what
+ *                   makes same-version replanning impossible in this phase.
+ *   work-in-progress  something eligible can still move — work a person
+ *                   supplied by hand, or this version's own plan — so get on
+ *                   with it rather than planning around it.
+ *
+ * `eligible` must be the VERSION-AWARE set (a `scopedQueue` listing), never the
+ * raw queue: counting an older plan's items as "work in progress" is how an
+ * amended goal would never get a plan of its own.
+ */
+function decideCompile(split, eligible, scope) {
+    if (scope === null)
+        return { compile: false, because: 'unbound' };
+    if (split.newerPlans.length)
+        return { compile: false, because: 'contradicted' };
+    if (split.currentPlan.length)
+        return { compile: false, because: 'plan-exists' };
+    // Spelt out rather than folded into the return, because which `workLeft`
+    // answers permit a compile is the whole anti-loop rule: `finished` and
+    // `stalled` and `none` all permit one, and only for a version with no plan.
+    if ((0, core_1.workLeft)(eligible) === 'working')
+        return { compile: false, because: 'work-in-progress' };
+    return { compile: true };
+}
+/**
+ * Durable evidence that this run must not act under.
+ *
+ * Returned as the offending items rather than a boolean so the refusal can say
+ * which ones and at what version, which is the only useful thing to tell
+ * somebody whose queue has been rewritten underneath them.
+ */
+function contradictingItems(items, scope) {
+    return items.filter((i) => (0, core_1.contradictsScope)((0, core_1.classifyForScope)(i, scope)));
+}
+/**
+ * Whether this row is the receipt a plan revision leaves, rather than work.
+ *
+ * Structural, not a flag: the id is derived from the goal, the version and the
+ * revision, so a row can only be a receipt by ALREADY having the id a receipt
+ * for those exact fields would have. Nothing can claim the exemption by
+ * asserting it.
+ */
+function isPlanReceipt(item, goalId) {
+    const version = item.compiledForGoalVersion;
+    const revision = item.compiledForPlanRevision;
+    if (item.state !== 'closed' || version === undefined || revision === undefined)
+        return false;
+    return item.id === (0, goal_compile_1.planMarkerId)(goalId, version, revision);
+}
+function stillTheAuthority(fresh, goalId, boundVersion, 
+/**
+ * The wording this run was BOUND to, when the caller still has it.
+ *
+ * ⚠️ OPTIONAL, AND ABSENT MEANS ABSENT. Three of the four places that refuse
+ * a superseded goal hold only one of the two texts — a Start carries an id
+ * and a number, and a queue's contradicting rows carry a version — so they
+ * genuinely cannot answer "which part changed" and are not asked to pretend.
+ * Given nothing, this says exactly what it said before.
+ */
+boundText) {
+    // Could not find out. NOT "the goal moved" — that would be a terminal
+    // refusal, told to a person, about a file that was briefly busy.
+    if (!fresh.ok)
+        return { ok: false, reason: fresh.because, lapse: 'unreadable', unknown: true };
+    const now = fresh.goals.find((g) => g.id === goalId) ?? null;
+    if (now === null)
+        return { ok: false, reason: 'it is no longer known on this machine', lapse: 'gone' };
+    if (now.version > boundVersion) {
+        /**
+         * WHAT MOVED, AND NOT ONLY THAT IT MOVED (the audit's C-05).
+         *
+         * The numbers were the whole sentence: a person was told their Start was
+         * refused because the goal is at 8 and they named 7, and left to find out
+         * for themselves whether the words they care about are among what changed.
+         * Both texts are in hand here whenever the caller has the binding — which
+         * is the case after a compile, the ten-minute window where this fires most
+         * — so the comparison is made rather than left to the reader.
+         *
+         * ⚠️ ADDED TO THE REASON, NOT TO THE SHAPE. `AuthorityLapse` gains no
+         * member, no branch changes its verdict, and nothing newly refuses: the
+         * four quarantines refuse exactly what they refused before. One sentence
+         * is read in four places — the first-plan compile note and three adaptive
+         * decisions — so saying more here says more in all of them, with no new
+         * path to keep in step.
+         */
+        const said = boundText === undefined ? '' : (0, core_1.describeWordingChange)((0, core_1.wordingChange)(boundText, now.text));
+        return { ok: false, reason: `it has moved on to version ${now.version}${said}`, lapse: 'superseded' };
+    }
+    if (now.version < boundVersion) {
+        // Behind what this Start is bound to. Not authority to act under: a mirror
+        // that went backwards is a mirror something rewrote, and writing here would
+        // be putting work behind the authority. A G@8 Start can never become a G@9
+        // one either — this only ever refuses, never re-binds.
+        return { ok: false, reason: `this machine’s copy has gone back to version ${now.version}`, lapse: 'behind' };
+    }
+    if (now.state !== 'active') {
+        // `abandoned` is the only non-active state a bound goal reaches in practice;
+        // `draft` would mean the server un-chose it, which is equally not authority.
+        return { ok: false, reason: `it is ${now.state}`, lapse: now.state === 'abandoned' ? 'abandoned' : 'gone' };
+    }
+    return { ok: true };
+}
+/**
+ * Write a compiled plan into the queue, as one durable batch.
+ *
+ * The choke point for the ownership invariant, and the only reason this is a
+ * function rather than a call to `insertAll` at the call site: EVERY item a
+ * compilation produces must be born owned by the goal it was compiled for, and
+ * this is where that is enforced rather than hoped for.
+ *
+ * The invariant is forced by selection, not chosen. `scopedQueue` filters
+ * symmetrically: an unowned compiled item would be invisible to the very run
+ * that compiled it, and visible to an unbound run that knows nothing about the
+ * goal. So an item arriving here without the right owner is a bug in the caller,
+ * and refusing the WHOLE batch is the only safe answer — a partial plan is a
+ * shape nobody asked for.
+ *
+ * Idempotent through `insertAll`: an id already in the queue is skipped, so a
+ * retry after a crash lands only what is missing, and a retry after a complete
+ * write lands nothing. That works precisely because compiled ids are derived
+ * from the goal, its version and the step, rather than minted per attempt.
+ */
+async function materialiseGoalPlan(queue, goalId, items) {
+    for (const item of items) {
+        if ((item.goalId ?? null) !== goalId) {
+            return {
+                ok: false,
+                problem: `compiled item ${item.id} is not owned by goal ${goalId} — refusing the whole plan`,
+            };
+        }
+        if (item.state !== 'draft' && !isPlanReceipt(item, goalId)) {
+            // Nothing in this system is born pickable. A compiled step is a claim
+            // that some work is worth doing; the verify pass is what turns a claim
+            // into something a round may pick.
+            //
+            // The one exception is the row a revision leaves to say it happened. It
+            // is born `closed`, which is STRICTER than draft rather than looser —
+            // nothing picks it, nothing verifies it, and it can never be `done` — and
+            // it is recognised by recomputing its own derived id from its own fields,
+            // so a hand-written closed row cannot pass as one.
+            return { ok: false, problem: `compiled item ${item.id} is born ${item.state}, not draft` };
+        }
+    }
+    const written = await queue.insertAll(items);
+    if (!written.ok) {
+        // The only failure `insertAll` reports is one id twice in one batch, which
+        // the compiler already collapses. Reaching this means a caller built the
+        // batch some other way.
+        return { ok: false, problem: `the plan names item ${written.id} twice` };
+    }
+    return { ok: true, created: written.inserted.length, alreadyThere: written.alreadyPresent.length };
+}
+/**
+ * Hand a set of items to a goal, all of them or none.
+ *
+ * One durable write, because the alternative — `update` per item — can be
+ * interrupted halfway and leave a goal owning some of what the phone named and
+ * not the rest, with nothing recording which. A caller retrying that has no way
+ * to tell a partial adoption from a fresh one.
+ *
+ * Every refusal names the item. Adoption is a deliberate act performed from a
+ * screen where the person can see the item, so "one of these is wrong" is not a
+ * useful answer.
+ */
+async function adoptGoalItems(queue, goalId, itemIds) {
+    const patches = [];
+    let alreadyOwned = 0;
+    for (const id of itemIds) {
+        const item = queue.get(id);
+        if (item === undefined)
+            return { ok: false, problem: `no item ${id} here` };
+        const owner = item.goalId ?? null;
+        if (owner === goalId) {
+            // Already ours. Counted rather than patched, so a redelivered start-run
+            // adopting the same set is a no-op instead of a version bump that would
+            // invalidate anything holding a copy.
+            alreadyOwned += 1;
+            continue;
+        }
+        if (owner !== null) {
+            // A transfer, not an adoption. Refused rather than performed: the other
+            // goal may have a run working this very item, and taking it silently is
+            // how two runs end up editing one item's code. Letting it go from the
+            // first goal is an explicit act with its own command.
+            return { ok: false, problem: `item ${id} belongs to goal ${owner} — let it go from there first` };
+        }
+        if (item.state === 'in_progress') {
+            // Unowned and in progress means a run without a goal is working it right
+            // now. Adopting it would move it out of that run's view mid-round.
+            return { ok: false, problem: `item ${id} is being worked on right now` };
+        }
+        patches.push({ id, expectedVersion: item.version, patch: { goalId } });
+    }
+    const written = await queue.patchAll(patches);
+    if (!written.ok)
+        return { ok: false, problem: describeBatchFailure(written) };
+    return { ok: true, adopted: written.items.length, alreadyOwned };
+}
+/**
+ * Let go of everything a goal owns that can still be worked.
+ *
+ * Takes no item ids, deliberately. The phone that abandons a goal does not know
+ * what that goal came to own — items are adopted over a whole evening, and a
+ * list assembled by a client is a list that is already stale. The instruction is
+ * "let this goal's work go"; the machine that holds the queue decides what that
+ * means, item by item, from {@link releaseOnAbandon}.
+ *
+ * Idempotent: running it twice releases nothing the second time, because there
+ * is nothing left owned that is releasable.
+ */
+async function releaseGoalItems(queue, goalId) {
+    const patches = [];
+    let heldByARun = 0;
+    let keptAsRecord = 0;
+    for (const item of queue.list()) {
+        if ((item.goalId ?? null) !== goalId)
+            continue;
+        const decision = (0, core_1.releaseOnAbandon)(item.state);
+        if (decision === 'held-by-a-run') {
+            heldByARun += 1;
+            continue;
+        }
+        if (decision === 'keeps-its-record') {
+            keptAsRecord += 1;
+            continue;
+        }
+        // Explicit null, not a deleted key. Both read as unowned, but a reader
+        // comparing two queue files should be able to see that something happened.
+        patches.push({ id: item.id, expectedVersion: item.version, patch: { goalId: null } });
+    }
+    const written = await queue.patchAll(patches);
+    if (!written.ok) {
+        // Every id and version came from a synchronous pass over the store's own
+        // map a moment ago, with no await in between, so there is no interleaving
+        // that could make one stale. Reachable only through a bug in this file.
+        throw new Error(`release: the queue refused a batch it produced itself — ${describeBatchFailure(written)}`);
+    }
+    return { released: written.items.length, heldByARun, keptAsRecord };
+}
+/**
+ * The real one, over the queue on disk.
+ *
+ * Two things here are load-bearing, and both were learned from a race that
+ * reached a state neither command's contract described.
+ *
+ * FIRST, it TAKES the tree rather than merely looking at it. The daemon and the
+ * run are separate processes over one `queue.json`; a check followed by a write
+ * leaves a window in which the run can take the lease and adopt in between, and
+ * the release then completes against a queue that no longer describes reality.
+ * The lease is already an exclusive create — the only mutual exclusion in this
+ * system — so the release holds it for the few milliseconds it writes, exactly
+ * as a run does. A `LeaseHeldError` is the busy answer, and it arrives from the
+ * filesystem rather than from a check that can go stale.
+ *
+ * SECOND, it writes the abandonment into the local goal mirror. Releasing the
+ * items is not enough on its own: a Start bound to G@7 that is still in flight,
+ * or that arrives later on a machine whose mirror is behind and offline, would
+ * resolve against `active` and adopt the very items this just freed — into a
+ * goal nobody is pursuing, with the one-shot release already acked and gone.
+ * The release IS this machine being told the goal was let go, so it remembers.
+ * That is not instant revocation and it does not need the server: a machine
+ * that has not heard still starts, exactly as before. It only refuses once it
+ * has carried the release out itself.
+ */
+function nodeGoalReleaser(stateDir, fs, leases, cliVersion, 
+/** The mirror to record the abandonment in. Absent in tests that do not keep one. */
+goals) {
+    return {
+        async release(goalId, goalVersion) {
+            let token;
+            try {
+                token = (await leases.acquire({
+                    // Honest about what is holding the tree and why. A release holds it
+                    // for a single write, so this is unlikely ever to be seen — but a
+                    // lease nobody can explain is worse than a wordy one.
+                    runId: `release-${goalId}`,
+                    branch: '(letting a goal go)',
+                    baseBranch: '(letting a goal go)',
+                    cliVersion,
+                })).token;
+            }
+            catch {
+                // Held by a live run, or not decidable. Both wait: the cost of being
+                // wrong is a lost round of work, and waiting costs only time.
+                return { busy: 'the working tree is busy — the release waits for it' };
+            }
+            try {
+                const queue = new queue_store_1.QueueStore(stateDir, fs);
+                await queue.open();
+                const outcome = await releaseGoalItems(queue, goalId);
+                // AFTER the items, so a crash between the two leaves the mirror still
+                // saying `active` and the release still deliverable — which retries
+                // correctly. The other order would leave a goal marked abandoned here
+                // with its work never freed and the command about to be acked.
+                await goals?.markAbandoned(goalId, goalVersion);
+                return outcome;
+            }
+            finally {
+                await leases.release(token);
+            }
+        },
+    };
+}
+function describeBatchFailure(r) {
+    switch (r.reason) {
+        case 'duplicate-id':
+            return 'the same item was named twice';
+        case 'not-found':
+            return `no item ${r.id} here`;
+        case 'stale-version':
+            return `item ${r.id} changed underneath this (now at version ${r.currentVersion})`;
+    }
+}
+//# sourceMappingURL=goal-ownership.js.map

package/dist/goal-ownership.js.map

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