@hotmeshio/long-tail 0.22.1 → 0.22.3

package/build/api/scan-codes/verbs-subject.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bags = bags;
+exports.claimGuard = claimGuard;
+exports.matchGuard = matchGuard;
+exports.failedAdd = failedAdd;
+exports.rendered = rendered;
+exports.accumulateFromSubject = accumulateFromSubject;
+exports.already = already;
+const scanCodeService = __importStar(require("../../services/scan-code"));
+const escalationService = __importStar(require("../../services/escalation"));
+const accumulate_1 = require("../escalations/accumulate");
+const helpers_1 = require("../escalations/helpers");
+const metadata_1 = require("../escalations/metadata");
+const escalation_1 = require("../../types/escalation");
+const types_1 = require("../../types");
+const context_1 = require("./context");
+const grant_1 = require("./grant");
+const subject_1 = require("./subject");
+// ── Acting on the held subject ──────────────────────────────────────────────
+//
+// The station holds an item; this scan names where it goes. The step checks
+// the pairing first (match), refusing with nothing written when it is wrong,
+// then writes by id in one atomic statement: the subject joins the scanned
+// container with its own row as the reciprocal (from: 'subject'), or the
+// subject's row collects the scanned code (into: 'subject', in
+// verb-into-subject.ts).
+const STOCK_REFUSAL = 'That is not where this one goes.';
+const STOCK_CONFLICT = 'That container just closed. Scan it again, or the next one.';
+const STOCK_PLACED = 'This one is already placed.';
+/** The step's template bags with the subject, the container, and the scanned item's row once located. */
+function bags(ctx, container, item) {
+    return {
+        ...(0, context_1.templateContext)(ctx),
+        ...(container ? { container: container.metadata ?? {} } : {}),
+        ...(item ? { item: item.metadata ?? {} } : {}),
+    };
+}
+/** Refuse the act when someone else holds a live claim on the subject. */
+async function claimGuard(step, ctx, subject) {
+    if (step.subject?.claimedByOther === 'allow')
+        return null;
+    const other = await (0, subject_1.claimedByOther)(subject.row, ctx.auth.userId);
+    return other ? (0, context_1.refused)(`Claimed by **${other.displayName}**.`) : null;
+}
+/** The container the scan names: a pending accumulator under the actor's read scope. */
+async function locateContainer(step, ctx) {
+    const selector = step.params?.accumulate?.container;
+    const scope = await (0, helpers_1.getEscalationReadScope)(ctx.auth.userId);
+    const roles = (0, metadata_1.restrictScopeRoles)(scope.allRoles, scope.global, selector?.roles ?? step.query?.roles);
+    if (roles !== null && roles.length === 0)
+        return null;
+    const found = await escalationService.searchByFacets({
+        roles: roles ?? undefined,
+        types: selector?.types,
+        subtypes: selector?.subtypes,
+        facets: { ...selector?.facets, [ctx.scheme.target_facet]: ctx.parsed.target },
+        status: 'pending',
+        exists: [escalation_1.ESCALATION_ACCUMULATE_KEYS.COUNT],
+        limit: 2,
+    }, { total: false });
+    return found.escalations.filter((row) => row.id !== ctx.subject?.row.id);
+}
+const WHOLE_BAG_TOKEN = /^\{(subject|container|item)\.([a-zA-Z0-9_]+)\}$/;
+/**
+ * One match.target template as the values it allows. A template that is a
+ * single bag token naming a list facet (`{subject.offeredContainers}`) allows every
+ * entry; anything else renders to one value. A token with nothing to read
+ * allows nothing.
+ */
+function expandTarget(template, tpl) {
+    const whole = template.match(WHOLE_BAG_TOKEN);
+    if (whole) {
+        const value = tpl[whole[1]]?.[whole[2]];
+        if (Array.isArray(value))
+            return value.filter((v) => v !== null && v !== '').map(String);
+    }
+    try {
+        return [scanCodeService.interpolateScanTemplate(template, tpl)];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The pre-write guard. Returns the refusal when the pairing is wrong, null
+ * when it holds (or the step declares no match).
+ */
+function matchGuard(step, ctx, container, item) {
+    const match = step.match;
+    if (!match)
+        return null;
+    const tpl = bags(ctx, container, item);
+    const expected = (match.target ?? []).flatMap((t) => expandTarget(t, tpl));
+    const targetOk = match.target === undefined || expected.includes(ctx.parsed.target);
+    const subjectMeta = (ctx.subject?.row.metadata ?? {});
+    const containerMeta = (container?.metadata ?? {});
+    // With no container located there is nothing to compare; the step falls through.
+    const facetsOk = match.facets === undefined || !container || (match.facets.every((f) => subjectMeta[f] !== undefined && subjectMeta[f] !== null && String(subjectMeta[f]) === String(containerMeta[f])));
+    if (targetOk && facetsOk)
+        return null;
+    const markdown = scanCodeService.renderScanCopy(step.refuse?.markdown ?? STOCK_REFUSAL, tpl);
+    return (0, context_1.refused)(markdown, { refusal: { markdown, ...(expected.length ? { expected } : {}) } });
+}
+const PLACED_OUTCOMES = ['reciprocal-terminal', 'reciprocal-full', 'reciprocal-duplicate'];
+/**
+ * Map a failed add onto what the bench says. 404 falls through. `keepSubject`
+ * leaves the hold in place when the reciprocal was already placed (the
+ * subject is the container the actor is still filling).
+ */
+function failedAdd(step, ctx, result, container, keepSubject = false) {
+    const outcome = result.data?.outcome;
+    if (result.status === 404)
+        return null;
+    if (result.status === 403)
+        return (0, context_1.forbidden)(result.error);
+    if (outcome && PLACED_OUTCOMES.includes(outcome)) {
+        return (0, context_1.refused)(STOCK_PLACED, { clearSubject: !keepSubject });
+    }
+    if (outcome === 'claimed-by-other' || outcome === 'claim-expired')
+        return (0, context_1.conflict)(result.error);
+    if (result.status === 409) {
+        const markdown = scanCodeService.renderScanCopy(step.refuse?.conflict ?? STOCK_CONFLICT, bags(ctx, container));
+        // A lost race for a shared container: the subject's offer may have moved, so drop it.
+        return (0, context_1.refused)(markdown, { clearSubject: !!step.refuse?.conflict });
+    }
+    return (0, context_1.refused)(result.error ?? STOCK_REFUSAL);
+}
+/** The step's itemKey, payload and metadata, or null when a template token has nothing to read. */
+function rendered(step, ctx, itemKeyDefault, item) {
+    const tpl = bags(ctx, undefined, item);
+    try {
+        return {
+            itemKey: scanCodeService.interpolateScanTemplate(step.params?.itemKey ?? itemKeyDefault ?? '', tpl),
+            payload: step.params?.resolverPayload
+                ? scanCodeService.interpolateScanTemplate(step.params.resolverPayload, tpl)
+                : undefined,
+            metadata: {
+                ...(step.params?.metadata ? scanCodeService.interpolateScanTemplate(step.params.metadata, tpl) : {}),
+                ...(0, context_1.provenance)(ctx),
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof scanCodeService.ScanTemplateError)
+            return null;
+        throw err;
+    }
+}
+/** The subject joins the scanned container; the subject's row is the reciprocal. */
+async function accumulateFromSubject(step, ctx) {
+    const subject = ctx.subject;
+    const claimed = await claimGuard(step, ctx, subject);
+    if (claimed)
+        return claimed;
+    // 1. Locate the container the scan names
+    const containers = await locateContainer(step, ctx);
+    if (containers && containers.length > 1) {
+        return (0, context_1.conflict)(`more than one open container carries ${ctx.scheme.target_facet} = ${ctx.parsed.target}`);
+    }
+    const container = containers?.[0];
+    // 2. Check the pairing before anything is written
+    const mismatch = matchGuard(step, ctx, container);
+    if (mismatch)
+        return mismatch;
+    if (!container) {
+        if (!step.refuse?.missing)
+            return null;
+        return (0, context_1.refused)(scanCodeService.renderScanCopy(step.refuse.missing, bags(ctx)));
+    }
+    // 3. Spend the badge, then write both rows in one statement
+    const values = rendered(step, ctx);
+    if (!values)
+        return null;
+    const notPrimed = (await (0, grant_1.identityGate)(step, ctx)) ?? (await (0, grant_1.spendGrant)(ctx));
+    if (notPrimed)
+        return notPrimed;
+    const result = await (0, accumulate_1.accumulateItem)({
+        id: container.id,
+        itemKey: values.itemKey,
+        payload: values.payload,
+        metadata: values.metadata,
+        reciprocal: { id: subject.row.id },
+    }, ctx.auth);
+    // 4. Report
+    if (result.status !== 200) {
+        if (result.data?.outcome === 'duplicate-item') {
+            return already(step, container);
+        }
+        return failedAdd(step, ctx, result, container);
+    }
+    return (0, context_1.withDone)({
+        status: 200,
+        data: {
+            outcome: types_1.SCAN_OUTCOMES.EXECUTED,
+            verb: step.verb,
+            escalation: { id: container.id, ...result.data },
+            clearSubject: true,
+        },
+    }, step, bags(ctx, container));
+}
+/** The item is already where the scan says: harmless, nothing written. */
+function already(step, row, keepSubject = false) {
+    return {
+        status: 200,
+        data: {
+            outcome: types_1.SCAN_OUTCOMES.EXECUTED,
+            verb: step.verb,
+            escalation: { id: row.id },
+            already: true,
+            clearSubject: !keepSubject,
+        },
+    };
+}

package/build/api/scan-codes/verbs.d.ts

@@ -1,41 +1,23 @@
 import { type ScanExecuteResponse, type ScanStep } from '../../types';
 import type { LTApiResult } from '../../types/sdk';
 import { type StepContext } from './context';
-export declare function claimStep(step: ScanStep, ctx: StepContext): Promise<LTApiResult<ScanExecuteResponse> | null>;
+/** Claims the scanned row; a presented choice passes the row it showed. */
+export declare function claimStep(step: ScanStep, ctx: StepContext, presentedId?: string): Promise<LTApiResult<ScanExecuteResponse> | null>;
 /**
  * Resolves the row the step's query names: the scanned target, the extra
  * facets, and the claim state, all inside the atomic statement. A presented
  * choice passes the row it showed, so the resolve lands on that row or misses.
  */
 export declare function resolveStep(step: ScanStep, ctx: StepContext, presentedId?: string): Promise<LTApiResult<ScanExecuteResponse> | null>;
-export declare function escalateStep(step: ScanStep, ctx: StepContext): Promise<LTApiResult<ScanExecuteResponse> | null>;
-export declare function releaseStep(step: ScanStep, ctx: StepContext): Promise<LTApiResult<ScanExecuteResponse> | null>;
+export declare function escalateStep(step: ScanStep, ctx: StepContext, presentedId?: string): Promise<LTApiResult<ScanExecuteResponse> | null>;
+export declare function releaseStep(step: ScanStep, ctx: StepContext, presentedId?: string): Promise<LTApiResult<ScanExecuteResponse> | null>;
 /**
- * Dispatch one CHOICE verb against an already-presented row. Unlike the step
- * walk (where a miss falls through to the next step), the screen showed this
- * exact row — so a miss answers with the truth: FORBIDDEN when the actor
- * holds no write scope here, CONFLICT when a concurrent actor won the race.
+ * Dispatch one CHOICE verb against an already-presented row. Every verb that
+ * writes the row writes that row by id, so a code shared by several rows
+ * never moves the write elsewhere. Unlike the step walk (where a miss falls
+ * through to the next step), a miss answers with the truth: FORBIDDEN when
+ * the actor holds no write scope here, CONFLICT when a concurrent actor won.
  */
 export declare function dispatchChoiceVerb(step: ScanStep, ctx: StepContext, row: Record<string, any>): Promise<LTApiResult<ScanExecuteResponse>>;
-export declare function cancelStep(step: ScanStep, ctx: StepContext): Promise<LTApiResult<ScanExecuteResponse> | null>;
-/**
- * Adds the scanned item to an accumulator. Two modes, one atomic write:
- *
- * - Item-locate (`params.accumulate.containerFacet`): the scan locates the
- *   item's own pending row through the scheme facet, reads the container
- *   facet value it carries, and adds the target to the container that shares
- *   it, writing the item row as the reciprocal in the same statement. An
- *   item with no row, or no container facet, falls through. An item whose
- *   container has closed and whose successor has not parked yet answers
- *   `no_open_container` with the item row, so the station can say "scan
- *   again" instead of showing the bag with no hint.
- * - Container-locate (no `containerFacet`): the scan locates the container
- *   by the scheme facet and adds `params.itemKey` (template).
- *
- * Templates may read `{claim.<facet>}` (the actor's live claim) and, in item
- * mode, `{item.<facet>}` (the located row); an unresolvable token falls
- * through. The write is the SDK's guarded statement; the locate only picks
- * ids. A container already holding the item answers conflict, never a
- * second add.
- */
-export declare function accumulateStep(step: ScanStep, ctx: StepContext): Promise<LTApiResult<ScanExecuteResponse> | null>;
+export declare function cancelStep(step: ScanStep, ctx: StepContext, presentedId?: string): Promise<LTApiResult<ScanExecuteResponse> | null>;
+export { accumulateStep } from './verb-accumulate';

package/build/api/scan-codes/verbs.js

@@ -33,52 +33,42 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.accumulateStep = void 0;
 exports.claimStep = claimStep;
 exports.resolveStep = resolveStep;
 exports.escalateStep = escalateStep;
 exports.releaseStep = releaseStep;
 exports.dispatchChoiceVerb = dispatchChoiceVerb;
 exports.cancelStep = cancelStep;
-exports.accumulateStep = accumulateStep;
 const scanCodeService = __importStar(require("../../services/scan-code"));
 const escalationService = __importStar(require("../../services/escalation"));
 const metadata_1 = require("../escalations/metadata");
-const accumulate_1 = require("../escalations/accumulate");
 const create_1 = require("../escalations/create");
 const claim_1 = require("../escalations/claim");
 const helpers_1 = require("../escalations/helpers");
 const types_1 = require("../../types");
 const context_1 = require("./context");
-const locate_1 = require("./locate");
+const grant_1 = require("./grant");
+const hold_1 = require("./hold");
 // ── Mutating verbs — each a single atomic operation under the ACTOR's RBAC ──
 // ctx.auth is the effective actor: the badged person when a grant rode the
 // request, otherwise the authenticated principal. Attribution and write
 // scoping both derive from it, live, inside the escalation APIs.
-/**
- * Interpolates a step's params, or falls through when a `{claim.…}` or
- * `{item.…}` token has nothing to read: a literal token never reaches a row.
- */
-async function templated(step, ctx, render, item) {
-    const tpl = await (0, context_1.stepTemplate)(step, ctx, item);
-    try {
-        return render(tpl);
-    }
-    catch (err) {
-        if (err instanceof scanCodeService.ScanTemplateError)
-            return null;
-        throw err;
-    }
-}
-async function claimStep(step, ctx) {
-    const metadata = await templated(step, ctx, (tpl) => (0, context_1.interpolatedMetadata)(step, ctx, tpl));
+/** Claims the scanned row; a presented choice passes the row it showed. */
+async function claimStep(step, ctx, presentedId) {
+    const metadata = await (0, context_1.templated)(step, ctx, (tpl) => (0, context_1.interpolatedMetadata)(step, ctx, tpl));
     if (metadata === null)
         return null;
+    const notPrimed = await (0, grant_1.spendGrant)(ctx);
+    if (notPrimed)
+        return notPrimed;
     const result = await (0, metadata_1.claimByMetadata)({
         key: ctx.scheme.target_facet,
         value: ctx.parsed.target,
         durationMinutes: step.params?.durationMinutes,
         metadata: { ...metadata, ...(0, context_1.provenance)(ctx) },
         restrictRoles: step.query?.roles,
+        assertId: presentedId,
     }, ctx.auth);
     if (result.status === 404)
         return null;
@@ -94,12 +84,15 @@ async function claimStep(step, ctx) {
  * choice passes the row it showed, so the resolve lands on that row or misses.
  */
 async function resolveStep(step, ctx, presentedId) {
-    const rendered = await templated(step, ctx, (tpl) => ({
+    const rendered = await (0, context_1.templated)(step, ctx, (tpl) => ({
         resolverPayload: scanCodeService.interpolateScanTemplate(step.params?.resolverPayload ?? {}, tpl),
         metadata: (0, context_1.interpolatedMetadata)(step, ctx, tpl),
     }));
     if (rendered === null)
         return null;
+    const notPrimed = await (0, grant_1.spendGrant)(ctx);
+    if (notPrimed)
+        return notPrimed;
     const result = await (0, metadata_1.resolveByMetadata)({
         key: ctx.scheme.target_facet,
         value: ctx.parsed.target,
@@ -116,30 +109,35 @@ async function resolveStep(step, ctx, presentedId) {
         return (0, context_1.forbidden)(result.error);
     if (result.status === 409)
         return (0, context_1.conflict)(result.error);
+    if (result.status === 400 || result.status === 422)
+        return (0, context_1.refused)(result.error ?? 'the payload was not accepted');
     if (result.status !== 200)
         return result;
     const escalation = result.data.escalation
         ?? (result.data.escalationId ? { id: result.data.escalationId } : undefined);
     return (0, context_1.executed)(escalation, step);
 }
-async function escalateStep(step, ctx) {
+async function escalateStep(step, ctx, presentedId) {
     // Close the located escalation first when configured — the close doubles as
     // the condition check AND the double-scan guard (second scan finds nothing
     // to close and falls through).
     if (step.params?.closeCurrent === 'resolve') {
-        const closed = await resolveStep({ ...step, params: { ...step.params, resolverPayload: step.params?.resolverPayload ?? {} } }, ctx);
+        const closed = await resolveStep({ ...step, params: { ...step.params, resolverPayload: step.params?.resolverPayload ?? {} } }, ctx, presentedId);
         if (closed === null)
             return null;
         if (closed.data?.outcome !== types_1.SCAN_OUTCOMES.EXECUTED)
             return closed;
     }
     else if (step.params?.closeCurrent === 'cancel') {
-        const cancelled = await cancelStep(step, ctx);
+        const cancelled = await cancelStep(step, ctx, presentedId);
         if (cancelled === null)
             return null;
         if (cancelled.data?.outcome !== types_1.SCAN_OUTCOMES.EXECUTED)
             return cancelled;
     }
+    const notPrimed = await (0, grant_1.spendGrant)(ctx);
+    if (notPrimed)
+        return notPrimed;
     const created = await (0, create_1.createEscalation)({
         type: step.params?.escalationType ?? 'scan',
         role: step.params.targetRole,
@@ -156,9 +154,11 @@ async function escalateStep(step, ctx) {
         return created;
     return (0, context_1.executed)(created.data, step);
 }
-async function releaseStep(step, ctx) {
+async function releaseStep(step, ctx, presentedId) {
     // Locate the caller's own claim; release-by-id re-asserts the assignee
     // inside the SDK, so a lost race resolves to 409, never a foreign release.
+    if (presentedId)
+        return releaseById(presentedId, step, ctx);
     const scope = await (0, helpers_1.getEscalationReadScope)(ctx.auth.userId);
     const readable = [...scope.allRoles, ...scope.selfRoles];
     const roles = (0, metadata_1.restrictScopeRoles)(readable, scope.global, step.query?.roles);
@@ -173,36 +173,45 @@ async function releaseStep(step, ctx) {
     });
     if (escalations.length === 0)
         return null;
-    const result = await (0, claim_1.releaseEscalation)({ id: escalations[0].id }, ctx.auth);
+    return releaseById(escalations[0].id, step, ctx);
+}
+async function releaseById(id, step, ctx) {
+    const notPrimed = await (0, grant_1.spendGrant)(ctx);
+    if (notPrimed)
+        return notPrimed;
+    const result = await (0, claim_1.releaseEscalation)({ id }, ctx.auth);
     if (result.status === 403)
         return (0, context_1.forbidden)(result.error);
-    if (result.status === 409)
+    if (result.status === 409 || result.status === 404)
         return (0, context_1.conflict)(result.error);
     if (result.status !== 200)
         return result;
     return (0, context_1.executed)(result.data.escalation, step);
 }
 /**
- * Dispatch one CHOICE verb against an already-presented row. Unlike the step
- * walk (where a miss falls through to the next step), the screen showed this
- * exact row — so a miss answers with the truth: FORBIDDEN when the actor
- * holds no write scope here, CONFLICT when a concurrent actor won the race.
+ * Dispatch one CHOICE verb against an already-presented row. Every verb that
+ * writes the row writes that row by id, so a code shared by several rows
+ * never moves the write elsewhere. Unlike the step walk (where a miss falls
+ * through to the next step), a miss answers with the truth: FORBIDDEN when
+ * the actor holds no write scope here, CONFLICT when a concurrent actor won.
  */
 async function dispatchChoiceVerb(step, ctx, row) {
     switch (step.verb) {
         case types_1.SCAN_VERBS.SHOW_DETAIL:
             return (0, context_1.executed)(row, step); // already located under the actor's scope
+        case types_1.SCAN_VERBS.HOLD:
+            return (await (0, hold_1.holdStep)(step, ctx, row));
         case types_1.SCAN_VERBS.CLAIM:
         case types_1.SCAN_VERBS.CLAIM_SHOW_DETAIL:
-            return (await claimStep(step, ctx)) ?? (await missReason(step, ctx, 'the item is no longer claimable'));
+            return (await claimStep(step, ctx, row.id)) ?? (await missReason(step, ctx, 'the item is no longer claimable'));
         case types_1.SCAN_VERBS.RESOLVE:
             return (await resolveStep(step, ctx, row.id)) ?? (await missReason(step, ctx, 'the item is no longer resolvable'));
         case types_1.SCAN_VERBS.ESCALATE:
-            return (await escalateStep(step, ctx)) ?? (await missReason(step, ctx, 'the item already moved on'));
+            return (await escalateStep(step, ctx, row.id)) ?? (await missReason(step, ctx, 'the item already moved on'));
         case types_1.SCAN_VERBS.RELEASE:
-            return (await releaseStep(step, ctx)) ?? (0, context_1.conflict)('no claim of yours to release');
+            return (await releaseStep(step, ctx, row.id)) ?? (0, context_1.conflict)('no claim of yours to release');
         case types_1.SCAN_VERBS.CANCEL:
-            return (await cancelStep(step, ctx)) ?? (await missReason(step, ctx, 'the item is no longer cancellable'));
+            return (await cancelStep(step, ctx, row.id)) ?? (await missReason(step, ctx, 'the item is no longer cancellable'));
         default:
             throw new Error(`unknown choice verb "${step.verb}"`);
     }
@@ -217,14 +226,18 @@ async function missReason(step, ctx, raceMessage) {
     }
     return (0, context_1.conflict)(raceMessage);
 }
-async function cancelStep(step, ctx) {
+async function cancelStep(step, ctx, presentedId) {
     // Claim-as-lock: the atomic claim pins the row to this caller (or extends
     // their claim), serializing concurrent double-scans before the cancel.
+    const notPrimed = await (0, grant_1.spendGrant)(ctx);
+    if (notPrimed)
+        return notPrimed;
     const claimed = await (0, metadata_1.claimByMetadata)({
         key: ctx.scheme.target_facet,
         value: ctx.parsed.target,
         metadata: (0, context_1.provenance)(ctx),
         restrictRoles: step.query?.roles,
+        assertId: presentedId,
     }, ctx.auth);
     if (claimed.status === 404)
         return null;
@@ -237,98 +250,5 @@ async function cancelStep(step, ctx) {
         return (0, context_1.conflict)('Escalation is not cancellable (already terminal)');
     return (0, context_1.executed)(cancelled, step);
 }
-/**
- * Adds the scanned item to an accumulator. Two modes, one atomic write:
- *
- * - Item-locate (`params.accumulate.containerFacet`): the scan locates the
- *   item's own pending row through the scheme facet, reads the container
- *   facet value it carries, and adds the target to the container that shares
- *   it, writing the item row as the reciprocal in the same statement. An
- *   item with no row, or no container facet, falls through. An item whose
- *   container has closed and whose successor has not parked yet answers
- *   `no_open_container` with the item row, so the station can say "scan
- *   again" instead of showing the bag with no hint.
- * - Container-locate (no `containerFacet`): the scan locates the container
- *   by the scheme facet and adds `params.itemKey` (template).
- *
- * Templates may read `{claim.<facet>}` (the actor's live claim) and, in item
- * mode, `{item.<facet>}` (the located row); an unresolvable token falls
- * through. The write is the SDK's guarded statement; the locate only picks
- * ids. A container already holding the item answers conflict, never a
- * second add.
- */
-async function accumulateStep(step, ctx) {
-    const options = step.params?.accumulate;
-    let item;
-    if (options?.containerFacet) {
-        const located = await (0, locate_1.locateForStep)(step, ctx, 1);
-        item = located?.escalations[0];
-        if (!item)
-            return null;
-    }
-    const rendered = await templated(step, ctx, (tpl) => ({
-        payload: step.params?.resolverPayload
-            ? scanCodeService.interpolateScanTemplate(step.params.resolverPayload, tpl)
-            : undefined,
-        metadata: { ...(0, context_1.interpolatedMetadata)(step, ctx, tpl), ...(0, context_1.provenance)(ctx) },
-        itemKey: options?.containerFacet
-            ? ctx.parsed.target
-            : scanCodeService.interpolateScanTemplate(step.params.itemKey, tpl),
-    }), item);
-    if (rendered === null)
-        return null;
-    let request;
-    let container;
-    if (options?.containerFacet && item) {
-        const containerValue = item.metadata?.[options.containerFacet];
-        if (containerValue === undefined || containerValue === null || containerValue === '')
-            return null;
-        container = { facet: options.containerFacet, value: String(containerValue) };
-        request = {
-            key: container.facet,
-            value: container.value,
-            itemKey: rendered.itemKey,
-            payload: rendered.payload,
-            metadata: rendered.metadata,
-            restrictRoles: options.container?.roles ?? options.containerRoles,
-            container: options.container
-                ? { types: options.container.types, subtypes: options.container.subtypes, facets: options.container.facets }
-                : undefined,
-            ...(options.reciprocal === false ? {} : { reciprocal: { id: item.id } }),
-        };
-    }
-    else {
-        request = {
-            key: ctx.scheme.target_facet,
-            value: ctx.parsed.target,
-            itemKey: rendered.itemKey,
-            payload: rendered.payload,
-            metadata: rendered.metadata,
-            restrictRoles: step.query?.roles,
-        };
-    }
-    const result = await (0, accumulate_1.accumulateItemByMetadata)(request, ctx.auth);
-    if (result.status === 404) {
-        if (!container || !item)
-            return null;
-        return {
-            status: 200,
-            data: {
-                outcome: types_1.SCAN_OUTCOMES.NO_OPEN_CONTAINER,
-                verb: step.verb,
-                escalation: item,
-                container,
-                fallback: ctx.rule.fallback,
-                error: `No open container carries ${container.facet} = ${container.value}`,
-            },
-        };
-    }
-    if (result.status === 403)
-        return (0, context_1.forbidden)(result.error);
-    if (result.status === 409)
-        return (0, context_1.conflict)(result.error);
-    if (result.status !== 200)
-        return result;
-    const escalation = result.data.escalationId ? { id: result.data.escalationId, ...result.data } : undefined;
-    return (0, context_1.executed)(escalation, step);
-}
+var verb_accumulate_1 = require("./verb-accumulate");
+Object.defineProperty(exports, "accumulateStep", { enumerable: true, get: function () { return verb_accumulate_1.accumulateStep; } });

package/build/index.d.ts

@@ -12,6 +12,7 @@ export * as TaskService from './services/task';
 export * as EscalationService from './services/escalation';
 export * as ConfigService from './services/config';
 export * as UserService from './services/user';
+export { assertValidScheme as assertValidScanScheme, assertValidSteps as assertValidScanSteps, assertValidIdentityRule as assertValidScanIdentityRule, isValidGtin, normalizeGtin, displayGtin, type ScanSchemeInput, type ScanRuleInput, } from './services/scan-code';
 export * as TopicService from './services/topics';
 export { seedSystemTopics, seedConfigTopics } from './services/topics/system-topics';
 export { ltConfig } from './modules/ltconfig';

package/build/index.js

@@ -36,8 +36,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.McpEscalationStrategy = exports.DefaultEscalationStrategy = exports.escalationStrategyRegistry = exports.McpVisionServer = exports.McpTranslationServer = exports.McpServer = exports.McpClient = exports.McpService = exports.BuiltInMcpAdapter = exports.mcpRegistry = exports.defaultMaintenanceConfig = exports.maintenanceRegistry = exports.PinoLoggerAdapter = exports.loggerRegistry = exports.HoneycombTelemetryAdapter = exports.telemetryRegistry = exports.publishKnowledgeEvent = exports.publishAgentEvent = exports.publishWorkflowEvent = exports.publishActivityEvent = exports.publishEscalationEvent = exports.publishTaskEvent = exports.publishMilestoneEvent = exports.SocketIOEventAdapter = exports.InMemoryEventAdapter = exports.NatsEventAdapter = exports.eventRegistry = exports.ltConfig = exports.seedConfigTopics = exports.seedSystemTopics = exports.TopicService = exports.UserService = exports.ConfigService = exports.EscalationService = exports.TaskService = exports.setAuthAdapter = exports.signToken = exports.requireAdmin = exports.requireAuth = exports.createAuthMiddleware = exports.JwtAuthAdapter = exports.conditionalAccumulator = exports.conditionLT = exports.conditional = exports.executeLT = exports.createLTActivityInterceptor = exports.createLTInterceptor = exports.registerLT = exports.midnightTheme = exports.start = void 0;
-exports.LTExpressAdapter = exports.api = exports.KnowledgeApi = exports.resolveCredential = exports.mimeFromPath = exports.getStorageBackend = exports.listOAuthConnections = exports.getFreshAccessToken = exports.createClient = exports.CallbackEventAdapter = exports.builtinMcpServerFactories = exports.getSystemAgents = exports.getSystemWorkers = exports.registerMcpTool = exports.getToolContext = exports.getActivityIdentity = void 0;
+exports.McpClient = exports.McpService = exports.BuiltInMcpAdapter = exports.mcpRegistry = exports.defaultMaintenanceConfig = exports.maintenanceRegistry = exports.PinoLoggerAdapter = exports.loggerRegistry = exports.HoneycombTelemetryAdapter = exports.telemetryRegistry = exports.publishKnowledgeEvent = exports.publishAgentEvent = exports.publishWorkflowEvent = exports.publishActivityEvent = exports.publishEscalationEvent = exports.publishTaskEvent = exports.publishMilestoneEvent = exports.SocketIOEventAdapter = exports.InMemoryEventAdapter = exports.NatsEventAdapter = exports.eventRegistry = exports.ltConfig = exports.seedConfigTopics = exports.seedSystemTopics = exports.TopicService = exports.displayGtin = exports.normalizeGtin = exports.isValidGtin = exports.assertValidScanIdentityRule = exports.assertValidScanSteps = exports.assertValidScanScheme = exports.UserService = exports.ConfigService = exports.EscalationService = exports.TaskService = exports.setAuthAdapter = exports.signToken = exports.requireAdmin = exports.requireAuth = exports.createAuthMiddleware = exports.JwtAuthAdapter = exports.conditionalAccumulator = exports.conditionLT = exports.conditional = exports.executeLT = exports.createLTActivityInterceptor = exports.createLTInterceptor = exports.registerLT = exports.midnightTheme = exports.start = void 0;
+exports.LTExpressAdapter = exports.api = exports.KnowledgeApi = exports.resolveCredential = exports.mimeFromPath = exports.getStorageBackend = exports.listOAuthConnections = exports.getFreshAccessToken = exports.createClient = exports.CallbackEventAdapter = exports.builtinMcpServerFactories = exports.getSystemAgents = exports.getSystemWorkers = exports.registerMcpTool = exports.getToolContext = exports.getActivityIdentity = exports.McpEscalationStrategy = exports.DefaultEscalationStrategy = exports.escalationStrategyRegistry = exports.McpVisionServer = exports.McpTranslationServer = exports.McpServer = void 0;
 const config_1 = require("./modules/config");
 const logger_1 = require("./lib/logger");
 const midnight_1 = require("./themes/midnight");
@@ -70,6 +70,13 @@ exports.TaskService = __importStar(require("./services/task"));
 exports.EscalationService = __importStar(require("./services/escalation"));
 exports.ConfigService = __importStar(require("./services/config"));
 exports.UserService = __importStar(require("./services/user"));
+var scan_code_1 = require("./services/scan-code");
+Object.defineProperty(exports, "assertValidScanScheme", { enumerable: true, get: function () { return scan_code_1.assertValidScheme; } });
+Object.defineProperty(exports, "assertValidScanSteps", { enumerable: true, get: function () { return scan_code_1.assertValidSteps; } });
+Object.defineProperty(exports, "assertValidScanIdentityRule", { enumerable: true, get: function () { return scan_code_1.assertValidIdentityRule; } });
+Object.defineProperty(exports, "isValidGtin", { enumerable: true, get: function () { return scan_code_1.isValidGtin; } });
+Object.defineProperty(exports, "normalizeGtin", { enumerable: true, get: function () { return scan_code_1.normalizeGtin; } });
+Object.defineProperty(exports, "displayGtin", { enumerable: true, get: function () { return scan_code_1.displayGtin; } });
 exports.TopicService = __importStar(require("./services/topics"));
 var system_topics_1 = require("./services/topics/system-topics");
 Object.defineProperty(exports, "seedSystemTopics", { enumerable: true, get: function () { return system_topics_1.seedSystemTopics; } });