@starci/hfs 4.11.21 → 4.12.0

package/report/sonar.mjs

@@ -12,7 +12,6 @@
 // byte-identical. A finding of level `info` (report-only) is not exported: the gate fails on any imported issue.
 import fs from 'node:fs';
 import path from 'node:path';
-
 const HFS_ENGINE = 'starci-hfs';
 const ESLINT_ENGINE = 'eslint';
 const STYLELINT_ENGINE = 'stylelint';
@@ -22,108 +21,99 @@ const CLEAN_CODE_ATTRIBUTE = 'CONVENTIONAL';
 const SOURCE_FILE = /\.(?:[cm]?[jt]sx?)$/;
 /** The files Sonar indexes under sonar.sources: the source files above and the stylesheets its CSS analyzer reads. */
 const INDEXED_FILE = /\.(?:[cm]?[jt]sx?|css)$/;
-
 const posix = (file) => file.split(path.sep).join('/').replace(/^\.\//, '');
 const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
-
 const ruleOf = (id, engineId, name, description) => ({ id, name, description, engineId, cleanCodeAttribute: CLEAN_CODE_ATTRIBUTE, impacts: IMPACT.map((impact) => ({ ...impact })) });
-
 const rangeOf = (line, endLine) => (Number.isInteger(line) && line >= 1 ? { textRange: { startLine: line, endLine: Number.isInteger(endLine) && endLine >= line ? endLine : line } } : {});
-
 function document(rules, issues) {
-  const sorted = [...issues].sort((a, b) => cmp(a.primaryLocation.filePath, b.primaryLocation.filePath)
-    || (a.primaryLocation.textRange?.startLine ?? 0) - (b.primaryLocation.textRange?.startLine ?? 0)
-    || cmp(a.ruleId, b.ruleId)
-    || cmp(a.primaryLocation.message, b.primaryLocation.message));
-  const used = new Set(sorted.map((issue) => issue.ruleId));
-  return { rules: [...rules.values()].filter((rule) => used.has(rule.id)).sort((a, b) => cmp(a.id, b.id)), issues: sorted };
+    const sorted = [...issues].sort((a, b) => cmp(a.primaryLocation.filePath, b.primaryLocation.filePath)
+        || (a.primaryLocation.textRange?.startLine ?? 0) - (b.primaryLocation.textRange?.startLine ?? 0)
+        || cmp(a.ruleId, b.ruleId)
+        || cmp(a.primaryLocation.message, b.primaryLocation.message));
+    const used = new Set(sorted.map((issue) => issue.ruleId));
+    return { rules: [...rules.values()].filter((rule) => used.has(rule.id)).sort((a, b) => cmp(a.id, b.id)), issues: sorted };
 }
-
 /** One document of several (the starci-hfs, eslint and stylelint documents of one app lint): rules by id, issues in the one sort order. */
 export function mergeReports(reports) {
-  const rules = new Map(reports.flatMap((report) => report.rules).map((rule) => [rule.id, rule]));
-  return document(rules, reports.flatMap((report) => report.issues));
+    const rules = new Map(reports.flatMap((report) => report.rules).map((rule) => [rule.id, rule]));
+    return document(rules, reports.flatMap((report) => report.issues));
 }
-
 /**
  * The first source file of the repository (sorted) under one of `sourceRoots`: Sonar imports an issue only on a file it
  * indexes, and a finding about hfs.json, a workflow, a config file or a directory is not on one, so it is filed on this
  * file and its message names the real path. Null when the tracked tree has no source file.
  */
 function anchorOf(tracked, sourceRoots) {
-  const roots = sourceRoots.map((root) => `${posix(root).replace(/\/$/, '')}/`);
-  return [...tracked].map(posix).filter((file) => SOURCE_FILE.test(file) && roots.some((root) => file.startsWith(root))).sort(cmp)[0] ?? null;
+    const roots = sourceRoots.map((root) => `${posix(root).replace(/\/$/, '')}/`);
+    return [...tracked].map(posix).filter((file) => SOURCE_FILE.test(file) && roots.some((root) => file.startsWith(root))).sort(cmp)[0] ?? null;
 }
-
 /**
  * The one placement rule of every engine. `sourceRoots` and `tracked` say which files Sonar indexes; without them every
  * finding keeps its own path. Returns `place(own, message, line, endLine)`: the `primaryLocation` of the finding (its own file,
  * or the anchor with the real path named in the message), or null when there is nowhere to file it.
  */
 function placement({ sourceRoots = [], tracked = [] }) {
-  const anchor = sourceRoots.length ? anchorOf(tracked, sourceRoots) : null;
-  const roots = sourceRoots.map((root) => `${posix(root).replace(/\/$/, '')}/`);
-  const trackedSet = new Set(tracked.map(posix));
-  // Sonar imports an issue only on a file it indexes: a tracked source file or stylesheet under sonar.sources (a directory, a config file or a JSON file is not one).
-  const indexed = (file) => roots.some((root) => file.startsWith(root)) && INDEXED_FILE.test(file) && (trackedSet.size === 0 || trackedSet.has(file));
-  return (own, message, line, endLine) => {
-    const moved = anchor !== null && (own === null || !indexed(own));
-    const filePath = moved ? anchor : own ?? anchor;
-    if (filePath === null) return null;
-    return { message: moved ? `${own ?? 'repository'}: ${message}` : message, filePath, ...(moved ? {} : rangeOf(line, endLine)) };
-  };
+    const anchor = sourceRoots.length ? anchorOf(tracked, sourceRoots) : null;
+    const roots = sourceRoots.map((root) => `${posix(root).replace(/\/$/, '')}/`);
+    const trackedSet = new Set(tracked.map(posix));
+    // Sonar imports an issue only on a file it indexes: a tracked source file or stylesheet under sonar.sources (a directory, a config file or a JSON file is not one).
+    const indexed = (file) => roots.some((root) => file.startsWith(root)) && INDEXED_FILE.test(file) && (trackedSet.size === 0 || trackedSet.has(file));
+    return (own, message, line, endLine) => {
+        const moved = anchor !== null && (own === null || !indexed(own));
+        const filePath = moved ? anchor : own ?? anchor;
+        if (filePath === null)
+            return null;
+        return { message: moved ? `${own ?? 'repository'}: ${message}` : message, filePath, ...(moved ? {} : rangeOf(line, endLine)) };
+    };
 }
-
 /**
  * The Generic Issue Import document of a check's findings (the `findings` of checkRepository, each with the catalog's
  * `title`, `titleVi`, `whyVi` and `nextStepVi`). `sourceRoots` and `tracked` place a finding that lies outside the indexed
  * sources (see placement); without them every finding keeps its own path.
  */
 export function sonarReport(findings, { sourceRoots = [], tracked = [] } = {}) {
-  const place = placement({ sourceRoots, tracked });
-  const rules = new Map();
-  const issues = [];
-  for (const finding of findings) {
-    if (finding.level !== 'error') continue;
-    if (!rules.has(finding.code)) {
-      rules.set(finding.code, ruleOf(finding.code, HFS_ENGINE, finding.title ?? finding.code, `${finding.title ?? finding.code}. ${finding.titleVi}: ${finding.whyVi} C\u00e1ch s\u1eeda: ${finding.nextStepVi}`));
+    const place = placement({ sourceRoots, tracked });
+    const rules = new Map();
+    const issues = [];
+    for (const finding of findings) {
+        if (finding.level !== 'error')
+            continue;
+        if (!rules.has(finding.code)) {
+            rules.set(finding.code, ruleOf(finding.code, HFS_ENGINE, finding.title ?? finding.code, `${finding.title ?? finding.code}. ${finding.titleVi}: ${finding.whyVi} C\u00e1ch s\u1eeda: ${finding.nextStepVi}`));
+        }
+        const primaryLocation = place(finding.path ? posix(finding.path) : null, finding.message, finding.line);
+        if (primaryLocation === null)
+            continue;
+        issues.push({ ruleId: finding.code, effortMinutes: 5, primaryLocation });
     }
-    const primaryLocation = place(finding.path ? posix(finding.path) : null, finding.message, finding.line);
-    if (primaryLocation === null) continue;
-    issues.push({ ruleId: finding.code, effortMinutes: 5, primaryLocation });
-  }
-  return document(rules, issues);
+    return document(rules, issues);
 }
-
 /** Text of a stylelint warning without the trailing " (rule-name)" its formatter appends. */
 const stylelintText = (warning) => String(warning.text ?? '').replace(new RegExp(`\\s*\\(${String(warning.rule ?? '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\)$`), '');
-
 // What differs between the two linters' json output: where the file, the findings, the rule and the text are.
 const LINTERS = Object.freeze({
-  eslint: {
-    engine: ESLINT_ENGINE,
-    errorRule: 'eslint-error',
-    file: (result) => result.filePath,
-    findings: (result) => result.messages,
-    rule: (message) => message.ruleId,
-    text: (message) => message.message,
-    describe: (id) => `ESLint rule ${id} of the StarCi canon (@starci/eslint-canon-be and @starci/eslint-canon-fe) or of a plugin it composes.`,
-    describeError: 'ESLint could not lint a file: a parse error or an invalid configuration.',
-  },
-  stylelint: {
-    engine: STYLELINT_ENGINE,
-    errorRule: 'stylelint-error',
-    file: (result) => result.source,
-    findings: (result) => result.warnings,
-    rule: (warning) => warning.rule,
-    text: stylelintText,
-    describe: (id) => `Stylelint rule ${id} of the StarCi CSS canon (@starci/stylelint-canon, HFS R61).`,
-    describeError: 'Stylelint could not read a stylesheet: a parse error or an invalid option.',
-  },
+    eslint: {
+        engine: ESLINT_ENGINE,
+        errorRule: 'eslint-error',
+        file: (result) => result.filePath,
+        findings: (result) => result.messages,
+        rule: (message) => message.ruleId,
+        text: (message) => message.message,
+        describe: (id) => `ESLint rule ${id} of the StarCi canon (@starci/eslint-canon-be and @starci/eslint-canon-fe) or of a plugin it composes.`,
+        describeError: 'ESLint could not lint a file: a parse error or an invalid configuration.',
+    },
+    stylelint: {
+        engine: STYLELINT_ENGINE,
+        errorRule: 'stylelint-error',
+        file: (result) => result.source,
+        findings: (result) => result.warnings,
+        rule: (warning) => warning.rule,
+        text: stylelintText,
+        describe: (id) => `Stylelint rule ${id} of the StarCi CSS canon (@starci/stylelint-canon, HFS R61).`,
+        describeError: 'Stylelint could not read a stylesheet: a parse error or an invalid option.',
+    },
 });
-
 const LINTER_KINDS = Object.freeze(Object.keys(LINTERS));
-
 /**
  * A linter's json results (`eslint -f json`: [{ filePath, messages: [{ ruleId, line, endLine, message }] }]; `stylelint
  * --formatter json`: [{ source, warnings: [{ line, endLine, rule, text }] }]) as a Generic Issue Import document. `root` is
@@ -132,34 +122,37 @@ const LINTER_KINDS = Object.freeze(Object.keys(LINTERS));
  * option is a finding the linter reports without a rule name; it is imported under the rule `eslint-error` / `stylelint-error`.
  */
 export function linterReport(kind, results, { root, sourceRoots = [], tracked = [] }) {
-  const linter = LINTERS[kind];
-  if (linter === undefined) throw new Error(`unknown linter ${kind}; expected ${LINTER_KINDS.join(' or ')}`);
-  const place = placement({ sourceRoots, tracked });
-  const rules = new Map();
-  const issues = [];
-  for (const result of results) {
-    const source = String(linter.file(result) ?? '');
-    if (!source) continue;
-    const relative = posix(path.isAbsolute(source) ? path.relative(root, source) : source);
-    if (relative.startsWith('..')) continue;
-    for (const finding of linter.findings(result) ?? []) {
-      const id = linter.rule(finding) || linter.errorRule;
-      if (!rules.has(id)) rules.set(id, ruleOf(id, linter.engine, id, id === linter.errorRule ? linter.describeError : linter.describe(id)));
-      const primaryLocation = place(relative, linter.text(finding) || id, finding.line, finding.endLine);
-      if (primaryLocation !== null) issues.push({ ruleId: id, effortMinutes: 5, primaryLocation });
+    const linter = LINTERS[kind];
+    if (linter === undefined)
+        throw new Error(`unknown linter ${kind}; expected ${LINTER_KINDS.join(' or ')}`);
+    const place = placement({ sourceRoots, tracked });
+    const rules = new Map();
+    const issues = [];
+    for (const result of results) {
+        const source = String(linter.file(result) ?? '');
+        if (!source)
+            continue;
+        const relative = posix(path.isAbsolute(source) ? path.relative(root, source) : source);
+        if (relative.startsWith('..'))
+            continue;
+        for (const finding of linter.findings(result) ?? []) {
+            const id = linter.rule(finding) || linter.errorRule;
+            if (!rules.has(id))
+                rules.set(id, ruleOf(id, linter.engine, id, id === linter.errorRule ? linter.describeError : linter.describe(id)));
+            const primaryLocation = place(relative, linter.text(finding) || id, finding.line, finding.endLine);
+            if (primaryLocation !== null)
+                issues.push({ ruleId: id, effortMinutes: 5, primaryLocation });
+        }
     }
-  }
-  return document(rules, issues);
+    return document(rules, issues);
 }
-
 /** The `sonar.sources` roots of a sonar-project.properties text (empty when the file does not name them). */
 export function sourceRootsOf(propertiesText) {
-  const line = String(propertiesText).split(/\r?\n/).map((raw) => raw.trim()).find((raw) => raw.startsWith('sonar.sources='));
-  return line ? line.slice('sonar.sources='.length).split(',').map((root) => root.trim()).filter(Boolean) : [];
+    const line = String(propertiesText).split(/\r?\n/).map((raw) => raw.trim()).find((raw) => raw.startsWith('sonar.sources='));
+    return line ? line.slice('sonar.sources='.length).split(',').map((root) => root.trim()).filter(Boolean) : [];
 }
-
 /** Write a report as JSON (2-space, LF, trailing newline), creating the directory. */
 export function writeReport(file, report) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(report, null, 2)}\n`);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(report, null, 2)}\n`);
 }

package/runtime/engine/admission.d.mts

@@ -0,0 +1,209 @@
+import type { SqlDb, SqlRow } from './db/sqlite-types.mjs';
+/** A durable job-shaped row as the ledger and machine stores return it (columns read by name). */
+export type JobRow = SqlRow;
+export type JsonObject = Record<string, any>;
+/** An owned path as callers spell it: the path itself, or a record carrying it as `path`. */
+export type OwnedPathSpec = string | {
+    path?: unknown;
+} | null | undefined;
+/** A request for capacity on one durable resource key. */
+export interface LeaseRequest {
+    resourceKey: string;
+    units: number;
+}
+/** Resolves a lease path to its app-relative form (scripts/kernel/lease-canon.mjs). */
+export type CanonicalOf = (path: string, row: SqlRow | null) => string | null | undefined;
+/** The retry accounting of one settled attempt. */
+export interface RetryDisposition {
+    retryClass: 'infrastructure' | 'owner-answer' | 'peer-blocked' | 'environment' | 'business';
+    effectState: unknown;
+    resumable: boolean;
+    consumesBusinessRetry: boolean;
+}
+/** The ceiling one workflow's concurrent operations are admitted at. */
+export interface OpSlotCeiling {
+    ceiling: number | null;
+    source: 'maxParallelOps' | 'budgets.maxOps' | null;
+}
+/** The admission of one more operation slot. */
+export interface OpSlotAdmission {
+    ok: boolean;
+    running: number;
+    ceiling: number | null;
+    ceilingSource: OpSlotCeiling['source'];
+    reason: 'max-ops' | null;
+}
+/** The decision of admitting one more try of a work unit. */
+export interface UnitTryAdmission {
+    tryNo: number;
+    retryOf: string | null;
+    resumeOf: string | null;
+    retryClass: 'business' | 'infra' | 'resume' | 'follow-up' | null;
+    reopen: {
+        reason: string;
+        by: string;
+    } | null;
+}
+/** A Next.js App Router bracket segment (`[id]`, `[...slug]`, `[[...opt]]`, `(.)[id]`) — a literal directory name. */
+export declare const isAppRouterSegment: (part: unknown) => boolean;
+/** A path segment that is a real glob (`*`, `?`, `{a,b}`, a bare character class), not an App Router name. */
+export declare const isGlobSegment: (part: unknown) => boolean;
+/**
+ * The git pathspec for one concrete owned path. Git reads a plain pathspec as a glob, so `src/app/[id]`
+ * would also match a sibling `src/app/i`; `:(literal)` pins it to the named directory. Admission
+ * refuses a glob, so every owned path is literal.
+ */
+export declare const ownedPathspec: (spec: unknown) => string;
+/**
+ * Canonical workspace-relative path prefix used by planning, leases and report boundaries. In a
+ * multi-repository project the caller includes the repository binding prefix (for example `my-app/`).
+ * A directory prefix is spelled either bare (`docs/`) or with a trailing `/**`, which normalizes to
+ * the same prefix; every other glob, absolute path and parent traversal is refused because it is not
+ * a concrete ownership boundary. A Next.js App Router segment (`[lang]`, `[...slug]`, `[[...opt]]`,
+ * `(group)`, `@slot`, `(.)photo`) is a literal directory name and is admitted as one.
+ */
+export declare function normalizeOwnedPath(value: OwnedPathSpec): string;
+/** Normalize, de-duplicate and collapse descendants already covered by an owned ancestor. */
+export declare function normalizeOwnedPaths(values?: readonly OwnedPathSpec[]): string[];
+/** Path-prefix overlap: equality or either concrete path being below the other. */
+export declare function ownedPathsIntersect(left: OwnedPathSpec, right: OwnedPathSpec): boolean;
+/** One capacity-one request per minimal owned prefix. */
+export declare const ownedPathLeaseRequests: (values: readonly OwnedPathSpec[]) => LeaseRequest[];
+/**
+ * The spelling two lease paths are compared in. The same file must compare equal however a workflow
+ * spelled it (a past incident had `apps/app/src/messages/vi.json` spelled bare for
+ * the fe repository while the repository-prefixed spelling of the same file never overlapped it). `canonicalOf`
+ * (scripts/kernel/lease-canon.mjs) resolves a path to its app-relative form in a bound app
+ * (be/<path>, fe/<path>) — for a held row through its holder job, so every spelling of one file
+ * compares as one key; paths on Windows compare case-insensitively, as its file
+ * systems do.
+ */
+export declare const leaseCompareForm: (leasePathValue: OwnedPathSpec, { canonicalOf, row, platform }?: {
+    canonicalOf?: CanonicalOf | null;
+    row?: SqlRow | null;
+    platform?: string;
+}) => string;
+/**
+ * Find durable path leases that overlap a requested parent/child prefix. Lease-row existence is the
+ * fence; expiry is only a recovery signal and does not by itself prove the prior worker has no effect.
+ * Both sides are compared in leaseCompareForm, so a bare and a repository-prefixed spelling of one
+ * file overlap and the same relative path in two repositories does not.
+ */
+export declare function findOwnedPathLeaseConflicts(db: SqlDb, requests: ReadonlyArray<string | {
+    resourceKey?: string;
+}>, { excludeJobId, canonicalOf, platform }?: {
+    excludeJobId?: string | null;
+    canonicalOf?: CanonicalOf | null;
+    platform?: string;
+}): SqlRow[];
+/** Existing durable path and resource checks, read inside the caller's reservation transaction. */
+export declare function resourceAdmission(db: SqlDb, repoNeeds: readonly LeaseRequest[], { at, canonicalOf }?: {
+    at?: number;
+    canonicalOf?: CanonicalOf | null;
+}): {
+    ok: boolean;
+    reason?: string;
+    reasons?: string[];
+    pathConflicts?: SqlRow[];
+};
+/**
+ * The concurrent-operation ceiling one workflow is admitted at. Two declared numbers meet here and
+ * the LOWER of them admits: the owner's `budgets.maxOps` (per workflow) and `maxParallelOps` from
+ * modules/models/runtimes.yaml (worker-wide). A null, absent or non-positive value is unbounded, so
+ * a workflow with no owner budget still meets the worker ceiling. A parallelism gear raises what
+ * `starci kernel estimate` requests and never raises either of these.
+ */
+export declare function opSlotCeiling({ maxOps, maxParallelOps }?: {
+    maxOps?: unknown;
+    maxParallelOps?: unknown;
+}): OpSlotCeiling;
+/**
+ * Admission against that ceiling. `running` is how many operations of the one workflow already hold
+ * a slot; a job at or above the ceiling is refused `max-ops` rather than launched and left to
+ * discover the cap from a provider.
+ */
+export declare function admitOpSlot({ running, maxOps, maxParallelOps }?: {
+    running?: unknown;
+    maxOps?: unknown;
+    maxParallelOps?: unknown;
+}): OpSlotAdmission;
+/** Count this workflow's durable held slots and judge the same declared ceiling at preflight and reservation. */
+export declare function workflowOpSlots(db: SqlDb, workflowId: string, { excludeJobId, holdingStatuses, maxOps, maxParallelOps }?: {
+    excludeJobId?: string | null;
+    holdingStatuses?: readonly string[];
+    maxOps?: unknown;
+    maxParallelOps?: unknown;
+}): OpSlotAdmission;
+/**
+ * The durable payload/result of a job-shaped row: the parsed object when the row carries the decoded
+ * field (a mapped ledger row), else the tolerant parse of its `*_json` text — a missing, blank or
+ * unparsable field reads as {}. Several scripts spell this by hand; these are the one pair to cite.
+ */
+export declare const payloadOf: (job?: JobRow | null) => JsonObject;
+export declare const resultOf: (job?: JobRow | null) => JsonObject;
+/** The settled verdict of an attempt that asked the owner and waits for the answer. */
+export declare const AWAITING_OWNER = "awaiting-owner";
+/**
+ * jobs.status of a try that ended asking the owner (report outcome ask): settled, but neither a failure nor a spent try
+ * (its unit's try budget and business retries ignore it). A retry or resume may follow it exactly as it follows `failed`.
+ */
+export declare const AWAITING_OWNER_STATUS = "awaiting_owner";
+export declare const RETRYABLE_JOB_STATUSES: readonly string[];
+/** Every jobs.status that holds nothing the runtime still needs. */
+export declare const SETTLED_JOB_LIST: readonly string[];
+/** The tries of a unit that spent budget: every try but the ones that only waited on the owner. */
+export declare const spentTries: (tries: readonly JobRow[]) => number;
+export declare const RETRY_CLASS_ENVIRONMENT = "environment";
+/**
+ * Classify a settled attempt for retry accounting. Infrastructure is free only when the durable result
+ * explicitly proves `effectState: none`; unknown or partial effects consume the ordinary business budget.
+ * An attempt settled `awaiting-owner` asked a question and did not fail: its successor is a new durable
+ * attempt (the ask attempt ran) that spends no business retry. Nor does one settled `peerBlocked`
+ * (starci kernel settle: every red check was a peer's change, scripts/kernel/gate-attribution.mjs), nor one settled
+ * with retryClass environment (RETRY_CLASS_ENVIRONMENT).
+ */
+export declare function retryDisposition(job?: JobRow | null): RetryDisposition;
+/**
+ * A row retired while still queued - `starci kernel reconcile --drop` (result.verdict `dropped`) or a goal revision
+ * that superseded it (result.reason `goal-revision-superseded`) - with no dispatch binding in its payload.
+ * It ran nothing, so it is no attempt: never a retry predecessor, never a cut seam, never the latest job
+ * of its ordinal (inc-5005d003825a: a retry chained to a dropped ordinal-1 row as business attempt 2 and
+ * lost the owner-answer lineage; inc-b428eb47fde3: ordinal 2 read a dropped seam as dependency-failed).
+ */
+export declare function retiredBeforeDispatch(job?: JobRow | null): boolean;
+/** The cut slice a job row carries, or null: {id, ordinal} identify one bounded SAME-op slice. */
+export declare function cutOf(job?: JobRow | null): {
+    id: string;
+    ordinal: number;
+    total: number;
+} | null;
+/** The default try budget of a unit (Q13; DBTREE work_units.try_budget). Only the owner or the Supervisor raises one. */
+export declare const UNIT_TRY_BUDGET = 5;
+/**
+ * The work identity of a job (DBTREE work_units.subject_key): a cut slice is `cut:<id>#<ordinal>`, an op about one
+ * named subject `subject:<s>`, else the digest of its records, else of its owned paths. One op, one subject key and
+ * one goal revision are ONE unit (UNIQUE(workflow_id, op_id, subject_key, goal_revision)): a try of the same work can
+ * never start a fresh budget.
+ */
+export declare function unitSubjectKey({ cut, params, records, ownedPaths }?: {
+    cut?: {
+        id?: unknown;
+        ordinal?: unknown;
+    } | null;
+    params?: {
+        subject?: unknown;
+    } | null;
+    records?: unknown;
+    ownedPaths?: unknown;
+}): string;
+/** Two jobs are tries of one work unit (jobs.unit_id). */
+export declare const sameUnit: (a?: JobRow | null, b?: JobRow | null) => boolean;
+export declare function admitUnitTry({ unit, tries, retryOf, reopen }?: {
+    unit?: SqlRow | null;
+    tries?: readonly JobRow[];
+    retryOf?: string | null;
+    reopen?: {
+        reason?: string;
+        by?: string;
+    } | null;
+}): UnitTryAdmission;