/** Code-unit lexical order — the shared comparator for every id sort here. */
export declare function compareCodeUnits(left: string, right: string): number;
export declare function isRecord(value: unknown): value is Record<string, unknown>;
/** Exact key set, order-insensitive: a persisted envelope admits no extra keys. */
export declare function hasExactKeys(value: Record<string, unknown>, expected: readonly string[]): boolean;
export declare function isSha256(value: unknown): value is string;
/** Full sha1/sha256 commit id — the only form a baseline may take. */
export declare function isCommit(value: unknown): value is string;
export declare function requireNonEmptyString(value: unknown, label: string): string;
export declare function stringArray(value: unknown): readonly string[] | null;
/** Element-wise equality of two string arrays (order-significant). */
export declare function sameStrings(left: readonly string[], right: readonly string[]): boolean;
/** The dedupe key for an accepted binding: work item × prompt digest. */
export declare function bindingIdentity(entry: {
    readonly work_item_id: string;
    readonly prompt_sha256: string;
}): string;
/**
 * The run-scoped paths one host-handoff boundary lives at.
 *
 * Both twins resolved these with the same three calls (`assertSubmissionRunId`,
 * containment on the artifacts dir, containment on `runs/<runId>`), differing
 * only in whether the run directory carried a sub-segment. The sub-segment is a
 * parameter here, not a fork: remediate's run dir sits under `runs/<id>/implement`
 * because its runs dir also holds triage/closing lanes; audit's sits directly
 * under `runs/<id>`.
 */
export interface HostHandoffPaths {
    /** Absolute repository root everything is contained beneath. */
    readonly root: string;
    /** Absolute artifacts dir (`.audit-tools/<tool>/`). */
    readonly artifactsDir: string;
    /** Absolute run directory the workload and results live under. */
    readonly runDir: string;
    /** Absolute directory submissions land in. */
    readonly resultDir: string;
    /** Absolute path of the persisted workload document. */
    readonly workloadPath: string;
}
/**
 * Resolve the run-scoped boundary paths. Throws when the run id leaves the
 * shared grammar or either declared root escapes containment — before any
 * caller has a path to write to.
 */
export declare function resolveHostHandoffPaths(params: {
    readonly root: string;
    readonly artifactsDir: string;
    readonly runId: string;
    /**
     * Segments between the RUN DIRECTORY and its lane sub-directory — i.e. AFTER
     * the run id: `runs/<runId>/<segments…>`. Empty for audit's flat
     * `runs/<runId>/`; `["implement"]` for remediate's lane-scoped one. Order is
     * load-bearing: validators join submissions to their run by the FIRST path
     * segment under `runs/`, so the run id must stay that segment.
     */
    readonly runDirSegments?: readonly string[];
    /** Names this draw in the run-id refusal (`Invalid <label>: …`). */
    readonly runIdLabel?: string;
}): HostHandoffPaths;
/**
 * The bound path for one work item's submission — the SHARED rule, not a local
 * copy of it. `<resultDir>/<sha256(id)>.json`, repository-relative and
 * forward-slashed. This replaces the byte-equivalent private `resultPathFor`
 * copies both twins carried; a divergence between them would have been silent
 * on both sides.
 */
export declare function hostHandoffResultPath(paths: HostHandoffPaths, id: string): string;
/** Absolute form of {@link hostHandoffResultPath}, for readers on disk. */
export declare function absoluteHostHandoffResultPath(paths: HostHandoffPaths, id: string): string;
/** Content digest of one prompt text — the binding between ask and answer. */
export declare function promptSha256(promptText: string): string;
/** Content digest of one canonical JSON rendering. */
export declare function contentSha256(value: unknown): string;
export type WorkloadEnvelopeParse = {
    readonly ok: true;
    readonly rawItems: readonly unknown[];
} | {
    readonly ok: false;
};
/**
 * Validate a persisted workload ENVELOPE against this run: exact keys, the
 * draw's contract version, the run id, and an array of raw items. Item-level
 * shape is the draw's parser ({@link parseAllWorkloadItems}); anything the
 * persisted trusted binding further pins (a digest, a baseline) is the draw's
 * policy layered on top of the `ok` case.
 */
export declare function parseWorkloadEnvelope(value: unknown, params: {
    readonly contractVersion: string;
    readonly runId: string;
}): WorkloadEnvelopeParse;
/** Map raw items through the draw's parser; `null` when ANY item refuses. */
export declare function parseAllWorkloadItems<T>(rawItems: readonly unknown[], parseItem: (raw: unknown) => T | null): readonly T[] | null;
/** Every id distinct — the duplicate-work-item refusal. */
export declare function idsAreUnique(ids: readonly string[]): boolean;
/**
 * Strictly ascending in code-unit order — which is BOTH "sorted" and
 * "duplicate-free", the two properties every persisted workload's id list must
 * have for a re-derivation to compare equal byte-for-byte.
 */
export declare function idsAreStrictlyAscending(ids: readonly string[]): boolean;
/**
 * The identity binding EVERY submitted result carries, identical on both
 * draws: a non-empty `result_id`, this run's id, this work item's id, and the
 * prompt digest of the ask. A refusal here is a REFUSAL, never a repair — the
 * tool cannot know which of the three the host meant.
 */
export declare function resultIdentityIsBound(value: Record<string, unknown>, params: {
    readonly runId: string;
    readonly workItemId: string;
    readonly promptSha256: string;
}): boolean;
/** The minimal view of a parsed work item the result-map check needs. */
export interface ResultMappedItem {
    readonly id: string;
    readonly prompt: {
        readonly sha256: string;
    };
    readonly result_path: string;
}
/** One `host-result-map.json` entry, as both draws persist it. */
export interface ResultMapEntry {
    readonly work_item_id: string;
    readonly prompt_sha256: string;
    readonly result_path: string;
}
/**
 * RESULT-MAP IDENTITY: the map names exactly the workload's items, once each,
 * with each item's own prompt digest and derived bound path. This was the
 * second half of the audit twin's `validateHandoffBinding`, hand-inlined there;
 * the remediate draw pins the same facts through its whole-document digest
 * instead — but the CHECK itself is the draw-independent statement of "the map
 * and the workload agree", so it lives here for whichever draw parses a map.
 *
 * The failure is CLASSIFIED, not collapsed: `coverage` means the map does not
 * name this workload's items exactly once each; `identity` means an entry
 * names the right item but pins another item's prompt digest or a bound path
 * the shared rule does not derive. The two are not interchangeable to the
 * caller — one says the MAP is wrong, the other names the BINDING that broke.
 */
export type ResultMapIdentity<TItem extends ResultMappedItem> = {
    readonly ok: true;
    readonly byId: ReadonlyMap<string, TItem>;
} | {
    readonly ok: false;
    readonly reason: "coverage" | "identity";
    readonly workItemId?: string;
};
export declare function resultMapIdentity<TItem extends ResultMappedItem>(items: readonly TItem[], entries: readonly ResultMapEntry[]): ResultMapIdentity<TItem>;
/**
 * First duplicate identity in `entries`, or null. The accepted-results ledger
 * and any other keyed record derives its dedupe refusal from this rather than
 * from a hand-rolled Set walk whose message and predicate can drift apart.
 */
export declare function firstDuplicateIdentity<T>(entries: readonly T[], identity: (entry: T) => string): T | null;
//# sourceMappingURL=hostHandoffCore.d.ts.map