@hotmeshio/long-tail 0.22.1 → 0.22.3

package/build/api/scan-codes/verb-accumulate.d.ts

@@ -0,0 +1,24 @@
+import { type ScanExecuteResponse, type ScanStep } from '../../types';
+import type { LTApiResult } from '../../types/sdk';
+import { type StepContext } from './context';
+/**
+ * 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 item 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>;

package/build/api/scan-codes/verb-accumulate.js

@@ -0,0 +1,151 @@
+"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.accumulateStep = accumulateStep;
+const scanCodeService = __importStar(require("../../services/scan-code"));
+const accumulate_1 = require("../escalations/accumulate");
+const types_1 = require("../../types");
+const context_1 = require("./context");
+const grant_1 = require("./grant");
+const locate_1 = require("./locate");
+const verbs_subject_1 = require("./verbs-subject");
+const verb_into_subject_1 = require("./verb-into-subject");
+/**
+ * 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 item 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;
+    if (options?.from === 'subject')
+        return (0, verbs_subject_1.accumulateFromSubject)(step, ctx);
+    if (options?.into === 'subject')
+        return (0, verb_into_subject_1.accumulateIntoSubject)(step, ctx);
+    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 (0, context_1.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,
+            ...(step.query?.types || step.query?.subtypes
+                ? { container: { types: step.query.types, subtypes: step.query.subtypes } }
+                : {}),
+        };
+    }
+    const notPrimed = await (0, grant_1.spendGrant)(ctx);
+    if (notPrimed)
+        return notPrimed;
+    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 === 400 || result.status === 422)
+        return (0, context_1.refused)(result.error ?? 'the item was not accepted');
+    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);
+}

package/build/api/scan-codes/verb-fill.d.ts

@@ -0,0 +1,6 @@
+import { type ScanExecuteResponse, type ScanStep } from '../../types';
+import type { LTApiResult } from '../../types/sdk';
+import { type StepContext } from './context';
+type ScanResult = LTApiResult<ScanExecuteResponse>;
+export declare function fillStep(step: ScanStep, ctx: StepContext): Promise<ScanResult | null>;
+export {};

package/build/api/scan-codes/verb-fill.js

@@ -0,0 +1,155 @@
+"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.fillStep = fillStep;
+const scanCodeService = __importStar(require("../../services/scan-code"));
+const escalationService = __importStar(require("../../services/escalation"));
+const resolve_batch_1 = require("../escalations/resolve-batch");
+const escalation_1 = require("../../types/escalation");
+const types_1 = require("../../types");
+const context_1 = require("./context");
+const grant_1 = require("./grant");
+const locate_1 = require("./locate");
+const subject_1 = require("./subject");
+const STOCK_UNEXPECTED = 'Not one of the items expected here.';
+function readBatch(row) {
+    const meta = (row.metadata ?? {});
+    const pending = meta[escalation_1.ESCALATION_BATCH_KEYS.PENDING];
+    const keys = meta[escalation_1.ESCALATION_BATCH_KEYS.KEYS];
+    if (!Array.isArray(pending))
+        return null;
+    return { pending: pending.map(String), keys: Array.isArray(keys) ? keys.map(String) : pending.map(String) };
+}
+/** The code a batch key names, without its ordinal suffix. */
+function codeOf(key, separator) {
+    const at = key.lastIndexOf(separator);
+    return at > 0 && /^[0-9]+$/.test(key.slice(at + 1)) ? key.slice(0, at) : key;
+}
+function keysFor(keys, target, separator) {
+    return keys.filter((k) => codeOf(k, separator) === target);
+}
+function progress(batch, filledNow) {
+    const remaining = Math.max(0, batch.pending.length - filledNow);
+    return { filled: batch.keys.length - remaining, total: batch.keys.length, remaining };
+}
+async function fillStep(step, ctx) {
+    const options = step.params.fill;
+    const separator = options.separator ?? types_1.SCAN_FILL_SEPARATOR_DEFAULT;
+    // 1. The batch row: the held subject, or the row the scan names
+    const row = options.into === 'subject'
+        ? ctx.subject.row
+        : (await (0, locate_1.locateForStep)(step, ctx, 1))?.escalations[0];
+    if (!row)
+        return null;
+    if (options.into === 'subject' && step.subject?.claimedByOther !== 'allow') {
+        const other = await (0, subject_1.claimedByOther)(row, ctx.auth.userId);
+        if (other)
+            return (0, context_1.refused)(`Claimed by **${other.displayName}**.`);
+    }
+    const batch = readBatch(row);
+    if (!batch)
+        return (0, context_1.conflict)('the held row is not a batch');
+    // 2. Which open slot this scan fills, or why none
+    const tpl = {
+        ...(0, context_1.templateContext)(ctx),
+        fill: {
+            pending: [...new Set(batch.pending.map((k) => codeOf(k, separator)))],
+            total: batch.keys.length,
+            filled: batch.keys.length - batch.pending.length,
+        },
+    };
+    const candidates = keysFor(batch.pending, ctx.parsed.target, separator);
+    if (candidates.length === 0) {
+        const declared = keysFor(batch.keys, ctx.parsed.target, separator);
+        const markdown = declared.length
+            ? `All ${declared.length} of these are already checked off.`
+            : scanCodeService.renderScanCopy(step.refuse?.markdown ?? STOCK_UNEXPECTED, tpl);
+        const expected = ctx.scheme.encoding === types_1.SCAN_ENCODINGS.GTIN
+            ? tpl.fill.pending.map((code) => scanCodeService.displayGtin(code))
+            : tpl.fill.pending;
+        return (0, context_1.refused)(markdown, {
+            refusal: { markdown, expected },
+            progress: progress(batch, 0),
+        });
+    }
+    // 3. Spend the badge, then fill; a slot taken since the read moves to the next
+    let payload;
+    try {
+        payload = scanCodeService.interpolateScanTemplate(options.payload ?? { scannedCode: '{scan.code}' }, tpl);
+    }
+    catch (err) {
+        if (err instanceof scanCodeService.ScanTemplateError)
+            return null;
+        throw err;
+    }
+    const notPrimed = (await (0, grant_1.identityGate)(step, ctx)) ?? (await (0, grant_1.spendGrant)(ctx));
+    if (notPrimed)
+        return notPrimed;
+    for (const itemKey of candidates) {
+        const result = await (0, resolve_batch_1.resolveBatchItem)({
+            id: row.id, itemKey, resolverPayload: payload, metadata: (0, context_1.provenance)(ctx),
+        }, ctx.auth);
+        if (result.status === 200) {
+            const data = result.data;
+            const done = data.outcome === 'completed';
+            const filled = progress(batch, batch.pending.length - (done ? 0 : (data.remaining ?? 0)));
+            return (0, context_1.withDone)({
+                status: 200,
+                data: {
+                    outcome: types_1.SCAN_OUTCOMES.EXECUTED,
+                    verb: step.verb,
+                    escalation: { id: row.id, ...data },
+                    progress: filled,
+                    ...(done ? { clearSubject: true } : {}),
+                },
+            }, step, { ...tpl, fill: { ...tpl.fill, ...filled } });
+        }
+        const outcome = result.data?.outcome;
+        if (outcome === 'duplicate-item')
+            continue;
+        if (result.status === 403)
+            return (0, context_1.forbidden)(result.error);
+        if (result.status === 404)
+            return null;
+        if (outcome?.startsWith('already-'))
+            return (0, context_1.refused)('This one is already complete.', { clearSubject: true });
+        return (0, context_1.refused)(result.error ?? STOCK_UNEXPECTED);
+    }
+    const fresh = await escalationService.getEscalation(row.id);
+    const after = fresh ? readBatch(fresh) : null;
+    return (0, context_1.refused)(`All ${keysFor(batch.keys, ctx.parsed.target, separator).length} of these are already checked off.`, {
+        ...(after ? { progress: progress(after, 0) } : {}),
+    });
+}

package/build/api/scan-codes/verb-into-subject.d.ts

@@ -0,0 +1,12 @@
+import { type ScanExecuteResponse, type ScanStep } from '../../types';
+import type { LTApiResult } from '../../types/sdk';
+import { type StepContext } from './context';
+type ScanResult = LTApiResult<ScanExecuteResponse>;
+/**
+ * The held subject's row collects the scanned code. With `accumulate.item`,
+ * the code's own pending row is located and written as the reciprocal in the
+ * same statement, so the item's record and the subject's entry land together
+ * or not at all.
+ */
+export declare function accumulateIntoSubject(step: ScanStep, ctx: StepContext): Promise<ScanResult | null>;
+export {};

package/build/api/scan-codes/verb-into-subject.js

@@ -0,0 +1,157 @@
+"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.accumulateIntoSubject = accumulateIntoSubject;
+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");
+const verbs_subject_1 = require("./verbs-subject");
+const STOCK_MISSING = 'That one is not waiting here.';
+const ITEM_GONE = ['reciprocal-not-found', 'reciprocal-not-accumulator'];
+/**
+ * The scanned code's own pending row: an accumulator carrying the scheme's
+ * target facet = the scanned target, within the selector and the actor's
+ * read scope. The held subject's row is never a candidate.
+ */
+async function locateItem(step, ctx) {
+    const selector = step.params.accumulate.item;
+    const scope = await (0, helpers_1.getEscalationReadScope)(ctx.auth.userId);
+    const roles = (0, metadata_1.restrictScopeRoles)(scope.allRoles, scope.global, selector.roles);
+    if (roles !== null && roles.length === 0)
+        return {};
+    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: 3,
+    }, { total: false });
+    const rows = found.escalations.filter((row) => row.id !== ctx.subject?.row.id);
+    return rows.length > 1 ? { ambiguous: true } : { row: rows[0] };
+}
+/** The missing-item answer: the rule's copy when declared, else fall through. */
+function missing(step, ctx) {
+    if (!step.refuse?.missing)
+        return null;
+    const copy = scanCodeService.renderScanCopy(step.refuse.missing, (0, verbs_subject_1.bags)(ctx, ctx.subject?.row));
+    return (0, context_1.refused)(copy, { clearSubject: false });
+}
+/** Progress of a bounded accumulator after an add; unbounded rows report none. */
+function progressOf(data) {
+    if (data.remaining === null || data.remaining === undefined)
+        return undefined;
+    return { filled: data.count, total: data.count + data.remaining, remaining: data.remaining };
+}
+/**
+ * The held subject's row collects the scanned code. With `accumulate.item`,
+ * the code's own pending row is located and written as the reciprocal in the
+ * same statement, so the item's record and the subject's entry land together
+ * or not at all.
+ */
+async function accumulateIntoSubject(step, ctx) {
+    const subject = ctx.subject;
+    const claimed = await (0, verbs_subject_1.claimGuard)(step, ctx, subject);
+    if (claimed)
+        return claimed;
+    // 1. Locate the scanned item's own row when the step names one
+    let item;
+    const wantsItem = !!step.params?.accumulate?.item;
+    if (wantsItem) {
+        const located = await locateItem(step, ctx);
+        if ('ambiguous' in located) {
+            return (0, context_1.conflict)(`more than one pending row carries ${ctx.scheme.target_facet} = ${ctx.parsed.target}`);
+        }
+        item = located.row;
+    }
+    // 2. Check the pairing before anything is written
+    if (wantsItem && !item)
+        return missing(step, ctx);
+    const mismatch = (0, verbs_subject_1.matchGuard)(step, ctx, subject.row, item);
+    if (mismatch)
+        return mismatch;
+    if (item && step.subject?.claimedByOther !== 'allow') {
+        const other = await (0, subject_1.claimedByOther)(item, ctx.auth.userId);
+        if (other)
+            return (0, context_1.refused)(`Claimed by **${other.displayName}**.`, { clearSubject: false });
+    }
+    // 3. Spend the badge, then write both rows in one statement
+    const values = (0, verbs_subject_1.rendered)(step, ctx, '{scan.target}', item);
+    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: subject.row.id,
+        itemKey: values.itemKey,
+        payload: values.payload,
+        metadata: values.metadata,
+        ...(item ? { reciprocal: { id: item.id } } : {}),
+    }, ctx.auth);
+    // 4. Report
+    if (result.status !== 200) {
+        const outcome = result.data?.outcome;
+        if (outcome === 'duplicate-item')
+            return (0, verbs_subject_1.already)(step, subject.row, true);
+        if (item && outcome && ITEM_GONE.includes(outcome))
+            return missing(step, ctx) ?? (0, context_1.refused)(STOCK_MISSING, { clearSubject: false });
+        return (0, verbs_subject_1.failedAdd)(step, ctx, result, subject.row, !!item);
+    }
+    const data = result.data;
+    const progress = progressOf(data);
+    return (0, context_1.withDone)({
+        status: 200,
+        data: {
+            outcome: types_1.SCAN_OUTCOMES.EXECUTED,
+            verb: step.verb,
+            escalation: { id: subject.row.id, ...result.data },
+            clearSubject: data.outcome === 'completed',
+            ...(progress ? { progress } : {}),
+        },
+    }, step, (0, verbs_subject_1.bags)(ctx, afterAdd(subject.row, values.metadata, data.count), item));
+}
+/** The subject's row as the add left it, for `{container.…}` copy, without a re-read. */
+function afterAdd(row, patch, count) {
+    return { ...row, metadata: { ...(row.metadata ?? {}), ...patch, [escalation_1.ESCALATION_ACCUMULATE_KEYS.COUNT]: count } };
+}

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

@@ -0,0 +1,33 @@
+import * as scanCodeService from '../../services/scan-code';
+import { type LTEscalationRecord, type ScanExecuteResponse, type ScanStep } from '../../types';
+import type { LTApiResult } from '../../types/sdk';
+import { type HeldSubject, type StepContext } from './context';
+type ScanResult = LTApiResult<ScanExecuteResponse>;
+/** The step's template bags with the subject, the container, and the scanned item's row once located. */
+export declare function bags(ctx: StepContext, container?: LTEscalationRecord, item?: LTEscalationRecord): scanCodeService.ScanTemplateContext;
+/** Refuse the act when someone else holds a live claim on the subject. */
+export declare function claimGuard(step: ScanStep, ctx: StepContext, subject: HeldSubject): Promise<ScanResult | null>;
+/**
+ * The pre-write guard. Returns the refusal when the pairing is wrong, null
+ * when it holds (or the step declares no match).
+ */
+export declare function matchGuard(step: ScanStep, ctx: StepContext, container?: LTEscalationRecord, item?: LTEscalationRecord): ScanResult | null;
+/**
+ * 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).
+ */
+export declare function failedAdd(step: ScanStep, ctx: StepContext, result: LTApiResult, container?: LTEscalationRecord, keepSubject?: boolean): ScanResult | null;
+/** The step's itemKey, payload and metadata, or null when a template token has nothing to read. */
+export declare function rendered(step: ScanStep, ctx: StepContext, itemKeyDefault?: string, item?: LTEscalationRecord): {
+    itemKey: string;
+    payload: Record<string, any> | undefined;
+    metadata: {
+        [x: string]: any;
+    };
+} | null;
+/** The subject joins the scanned container; the subject's row is the reciprocal. */
+export declare function accumulateFromSubject(step: ScanStep, ctx: StepContext): Promise<ScanResult | null>;
+/** The item is already where the scan says: harmless, nothing written. */
+export declare function already(step: ScanStep, row: LTEscalationRecord, keepSubject?: boolean): ScanResult;
+export {};