@aexhq/sdk 0.46.5-canary → 0.51.0

package/dist/_contracts/session-custody.d.ts

@@ -1,165 +0,0 @@
-import type { ProviderName } from "./submission.js";
-export declare const CUSTODY_MANIFEST_SCHEMA_VERSION = 1;
-export declare const CUSTODY_REDACTION_SCANNER_VERSION = 1;
-export declare const CUSTODY_MANIFEST_KIND = "aex.custody_manifest.v1";
-export declare const CUSTODY_MANIFEST_CONTENT_TYPE = "application/json; charset=utf-8";
-export declare const CUSTODY_MANIFEST_SESSION_REL_PATH = "metadata/custody.json";
-export declare const CUSTODY_SECRET_CLASSES: readonly ["provider_api_key", "mcp_credential", "proxy_endpoint_auth", "runner_bearer", "managed_system_credential"];
-export type CustodySecretClass = (typeof CUSTODY_SECRET_CLASSES)[number];
-export declare const CUSTODY_RESOURCE_CLASSES: readonly ["runtime_machine", "proxy_token", "execution_secret", "event_archive", "session_file", "session_log", "session_asset"];
-export type CustodyResourceClass = (typeof CUSTODY_RESOURCE_CLASSES)[number];
-export declare const CUSTODY_EXPOSURE_SURFACES: readonly ["aex_vault", "aex_kv", "host_env", "host_file", "dashboard_proxy", "api_provider_proxy", "api_mcp_proxy", "session_artifact_store", "coordinator_event_archive"];
-export type CustodyExposureSurface = (typeof CUSTODY_EXPOSURE_SURFACES)[number];
-export declare const CUSTODY_EXPOSURE_ACCESS_KINDS: readonly ["stored", "injected", "proxied", "replicated", "observed", "unknown"];
-export type CustodyExposureAccessKind = (typeof CUSTODY_EXPOSURE_ACCESS_KINDS)[number];
-export declare const CUSTODY_EXPOSURE_STATUSES: readonly ["exposed", "revoked", "retained", "failed", "not_applicable"];
-export type CustodyExposureStatus = (typeof CUSTODY_EXPOSURE_STATUSES)[number];
-export declare const CUSTODY_DISPOSITION_STATUSES: readonly ["destroyed", "revoked", "not_found", "retained_by_policy", "cleanup_failed", "parked_for_operator", "pending", "not_applicable"];
-export type CustodyDispositionStatus = (typeof CUSTODY_DISPOSITION_STATUSES)[number];
-export declare const CUSTODY_CLEANUP_STATUSES: readonly ["succeeded", "partial", "failed", "retained", "pending"];
-export type CustodyCleanupStatus = (typeof CUSTODY_CLEANUP_STATUSES)[number];
-export declare const CUSTODY_EVIDENCE_SOURCES: readonly ["session_row", "runtime_manifest", "terminal_event", "cleanup_step", "file_capture", "proxy_audit", "provider_cleanup_summary"];
-export type CustodyEvidenceSource = (typeof CUSTODY_EVIDENCE_SOURCES)[number];
-export declare const CUSTODY_MANIFEST_EXCLUDED_VALUE_CLASSES: readonly ["raw_secret_values", "bearer_hashes", "provider_response_bodies", "signed_urls", "object_store_keys", "vault_ids", "private_resource_handles"];
-export type CustodyManifestExcludedValueClass = (typeof CUSTODY_MANIFEST_EXCLUDED_VALUE_CLASSES)[number];
-export interface CustodyManifestSessionV1 {
-    readonly sessionId: string;
-    readonly workspaceId: string;
-    readonly provider: ProviderName | string;
-    readonly terminalStatus: string;
-    readonly createdAt?: string;
-    readonly terminalAt?: string;
-}
-export interface CustodyManifestExposureV1 {
-    readonly surface: CustodyExposureSurface | string;
-    readonly access: CustodyExposureAccessKind;
-    readonly status?: CustodyExposureStatus;
-    readonly count?: number;
-    readonly firstExposedAt?: string;
-    readonly lastExposedAt?: string;
-    readonly revokedAt?: string;
-}
-export interface CustodyManifestDispositionV1 {
-    readonly status: CustodyDispositionStatus;
-    readonly reason?: string;
-    readonly decidedAt?: string;
-    readonly errorClass?: string;
-    readonly followUpRequired?: boolean;
-}
-export interface CustodyManifestEvidenceSummaryV1 {
-    readonly source: CustodyEvidenceSource | string;
-    readonly status?: string;
-    readonly observedAt?: string;
-    readonly count?: number;
-    readonly errorClass?: string;
-}
-export interface CustodyManifestSecretClassV1 {
-    readonly class: CustodySecretClass | string;
-    readonly present: boolean;
-    readonly count: number;
-    readonly exposures: readonly CustodyManifestExposureV1[];
-    readonly disposition: CustodyManifestDispositionV1;
-    readonly evidence?: readonly CustodyManifestEvidenceSummaryV1[];
-}
-export interface CustodyManifestResourceClassV1 {
-    readonly class: CustodyResourceClass | string;
-    readonly count: number;
-    readonly exposures: readonly CustodyManifestExposureV1[];
-    readonly disposition: CustodyManifestDispositionV1;
-    readonly evidence?: readonly CustodyManifestEvidenceSummaryV1[];
-}
-export interface CustodyManifestCleanupV1 {
-    readonly status: CustodyCleanupStatus;
-    readonly startedAt?: string;
-    readonly finishedAt?: string;
-    readonly errorClass?: string;
-    readonly followUpRequiredCount?: number;
-}
-export interface CustodyManifestSummaryV1 {
-    readonly secretClassCount: number;
-    readonly secretInstanceCount: number;
-    readonly resourceClassCount: number;
-    readonly resourceInstanceCount: number;
-    readonly exposureCount: number;
-    readonly revokedExposureCount: number;
-    readonly retainedCount: number;
-    readonly cleanupFailedCount: number;
-    readonly parkedForOperatorCount: number;
-    readonly pendingCount: number;
-    readonly followUpRequiredCount: number;
-    readonly dispositionCounts: Readonly<Partial<Record<CustodyDispositionStatus, number>>>;
-}
-export interface CustodyManifestRedactionV1 {
-    readonly policy: "metadata_only";
-    readonly scannerVersion: typeof CUSTODY_REDACTION_SCANNER_VERSION;
-    readonly excludes: readonly CustodyManifestExcludedValueClass[];
-}
-export interface CustodyManifestV1 {
-    readonly schemaVersion: typeof CUSTODY_MANIFEST_SCHEMA_VERSION;
-    readonly kind: typeof CUSTODY_MANIFEST_KIND;
-    readonly generatedAt: string;
-    readonly finalizedAt?: string;
-    readonly session: CustodyManifestSessionV1;
-    readonly secrets: readonly CustodyManifestSecretClassV1[];
-    readonly resources: readonly CustodyManifestResourceClassV1[];
-    readonly cleanup: CustodyManifestCleanupV1;
-    readonly summary: CustodyManifestSummaryV1;
-    readonly redaction: CustodyManifestRedactionV1;
-}
-export type CustodyManifestSessionInput = CustodyManifestSessionV1;
-export type CustodyManifestExposureInput = CustodyManifestExposureV1;
-export type CustodyManifestDispositionInput = CustodyManifestDispositionV1;
-export type CustodyManifestEvidenceSummaryInput = CustodyManifestEvidenceSummaryV1;
-export type CustodyManifestCleanupInput = CustodyManifestCleanupV1;
-export interface CustodyManifestSecretClassInput extends Omit<CustodyManifestSecretClassV1, "count" | "exposures"> {
-    readonly count?: number;
-    readonly exposures?: readonly CustodyManifestExposureInput[];
-}
-export interface CustodyManifestResourceClassInput extends Omit<CustodyManifestResourceClassV1, "count" | "exposures"> {
-    readonly count?: number;
-    readonly exposures?: readonly CustodyManifestExposureInput[];
-}
-export interface CustodyManifestInput {
-    readonly generatedAt: string;
-    readonly finalizedAt?: string;
-    readonly session: CustodyManifestSessionInput;
-    readonly secrets?: readonly CustodyManifestSecretClassInput[];
-    readonly resources?: readonly CustodyManifestResourceClassInput[];
-    readonly cleanup?: CustodyManifestCleanupInput;
-}
-export interface CustodyManifestWriteObject {
-    readonly key: string;
-    readonly contentType: typeof CUSTODY_MANIFEST_CONTENT_TYPE;
-    readonly manifest: CustodyManifestV1;
-}
-export interface CustodyManifestObjectStore {
-    putCustodyManifestObject(object: CustodyManifestWriteObject): Promise<void>;
-}
-export interface CustodyManifestWriteResult {
-    readonly status: "written";
-    readonly schemaVersion: typeof CUSTODY_MANIFEST_SCHEMA_VERSION;
-    readonly sessionId: string;
-    readonly workspaceId: string;
-    readonly key: string;
-    readonly writtenAt: string;
-}
-export interface CustodyManifestWriter {
-    writeCustodyManifest(input: CustodyManifestInput): Promise<CustodyManifestWriteResult>;
-}
-export type CustodyRedactionReason = "forbidden_field_name" | "uninspectable_value" | "bearer_token" | "provider_key" | "signed_url" | "object_store_key" | "vault_id" | "private_resource_handle" | "high_entropy_token";
-export interface CustodyRedactionFinding {
-    readonly path: string;
-    readonly reason: CustodyRedactionReason;
-    readonly valueLength?: number;
-}
-export declare class CustodyManifestRedactionError extends Error {
-    readonly code = "custody_manifest_not_public_safe";
-    readonly findings: readonly CustodyRedactionFinding[];
-    constructor(findings: readonly CustodyRedactionFinding[]);
-}
-export declare function custodyManifestObjectKey(sessionId: string): string;
-export declare function createCustodyManifestWriter(store: CustodyManifestObjectStore): CustodyManifestWriter;
-export declare function writeCustodyManifest(store: CustodyManifestObjectStore, input: CustodyManifestInput): Promise<CustodyManifestWriteResult>;
-export declare function buildCustodyManifest(input: CustodyManifestInput): CustodyManifestV1;
-export declare function scanCustodyPayloadForSensitiveValues(input: unknown): readonly CustodyRedactionFinding[];
-export declare function assertPublicSafeCustodyPayload(input: unknown): void;

package/dist/_contracts/session-custody.js

@@ -1,345 +0,0 @@
-import { createForbiddenFieldNamePredicate, isPlatformContentDigest, privateResourceHandlePattern, PUBLIC_SAFE_SECRET_PATTERNS, scanPublicSafePayload } from "./sdk-secrets.js";
-export const CUSTODY_MANIFEST_SCHEMA_VERSION = 1;
-export const CUSTODY_REDACTION_SCANNER_VERSION = 1;
-export const CUSTODY_MANIFEST_KIND = "aex.custody_manifest.v1";
-export const CUSTODY_MANIFEST_CONTENT_TYPE = "application/json; charset=utf-8";
-export const CUSTODY_MANIFEST_SESSION_REL_PATH = "metadata/custody.json";
-export const CUSTODY_SECRET_CLASSES = [
-    "provider_api_key",
-    "mcp_credential",
-    "proxy_endpoint_auth",
-    "runner_bearer",
-    "managed_system_credential"
-];
-export const CUSTODY_RESOURCE_CLASSES = [
-    "runtime_machine",
-    "proxy_token",
-    "execution_secret",
-    "event_archive",
-    "session_file",
-    "session_log",
-    "session_asset"
-];
-export const CUSTODY_EXPOSURE_SURFACES = [
-    "aex_vault",
-    "aex_kv",
-    "host_env",
-    "host_file",
-    "dashboard_proxy",
-    "api_provider_proxy",
-    "api_mcp_proxy",
-    "session_artifact_store",
-    "coordinator_event_archive"
-];
-export const CUSTODY_EXPOSURE_ACCESS_KINDS = [
-    "stored",
-    "injected",
-    "proxied",
-    "replicated",
-    "observed",
-    "unknown"
-];
-export const CUSTODY_EXPOSURE_STATUSES = [
-    "exposed",
-    "revoked",
-    "retained",
-    "failed",
-    "not_applicable"
-];
-export const CUSTODY_DISPOSITION_STATUSES = [
-    "destroyed",
-    "revoked",
-    "not_found",
-    "retained_by_policy",
-    "cleanup_failed",
-    "parked_for_operator",
-    "pending",
-    "not_applicable"
-];
-export const CUSTODY_CLEANUP_STATUSES = [
-    "succeeded",
-    "partial",
-    "failed",
-    "retained",
-    "pending"
-];
-export const CUSTODY_EVIDENCE_SOURCES = [
-    "session_row",
-    "runtime_manifest",
-    "terminal_event",
-    "cleanup_step",
-    "file_capture",
-    "proxy_audit",
-    "provider_cleanup_summary"
-];
-export const CUSTODY_MANIFEST_EXCLUDED_VALUE_CLASSES = [
-    "raw_secret_values",
-    "bearer_hashes",
-    "provider_response_bodies",
-    "signed_urls",
-    "object_store_keys",
-    "vault_ids",
-    "private_resource_handles"
-];
-export class CustodyManifestRedactionError extends Error {
-    code = "custody_manifest_not_public_safe";
-    findings;
-    constructor(findings) {
-        super(`custody manifest contains non-public custody data at ${formatFindingPaths(findings)}`);
-        this.name = "CustodyManifestRedactionError";
-        this.findings = Object.freeze([...findings]);
-    }
-}
-export function custodyManifestObjectKey(sessionId) {
-    assertSafeIdentifier(sessionId, "sessionId");
-    return `sessions/${sessionId}/${CUSTODY_MANIFEST_SESSION_REL_PATH}`;
-}
-export function createCustodyManifestWriter(store) {
-    return {
-        async writeCustodyManifest(input) {
-            return writeCustodyManifest(store, input);
-        }
-    };
-}
-export async function writeCustodyManifest(store, input) {
-    const manifest = buildCustodyManifest(input);
-    const key = custodyManifestObjectKey(manifest.session.sessionId);
-    await store.putCustodyManifestObject({
-        key,
-        contentType: CUSTODY_MANIFEST_CONTENT_TYPE,
-        manifest
-    });
-    return Object.freeze({
-        status: "written",
-        schemaVersion: CUSTODY_MANIFEST_SCHEMA_VERSION,
-        sessionId: manifest.session.sessionId,
-        workspaceId: manifest.session.workspaceId,
-        key,
-        writtenAt: manifest.finalizedAt ?? manifest.generatedAt
-    });
-}
-export function buildCustodyManifest(input) {
-    const secrets = Object.freeze((input.secrets ?? []).map(normalizeSecretClass));
-    const resources = Object.freeze((input.resources ?? []).map(normalizeResourceClass));
-    const cleanup = normalizeCleanup(input.cleanup);
-    const manifest = Object.freeze({
-        schemaVersion: CUSTODY_MANIFEST_SCHEMA_VERSION,
-        kind: CUSTODY_MANIFEST_KIND,
-        generatedAt: assertTimestamp(input.generatedAt, "generatedAt"),
-        ...(input.finalizedAt ? { finalizedAt: assertTimestamp(input.finalizedAt, "finalizedAt") } : {}),
-        session: normalizeSession(input.session),
-        secrets,
-        resources,
-        cleanup,
-        summary: buildCustodySummary(secrets, resources, cleanup),
-        redaction: Object.freeze({
-            policy: "metadata_only",
-            scannerVersion: CUSTODY_REDACTION_SCANNER_VERSION,
-            excludes: Object.freeze([...CUSTODY_MANIFEST_EXCLUDED_VALUE_CLASSES])
-        })
-    });
-    assertPublicSafeCustodyPayload(manifest);
-    return manifest;
-}
-export function scanCustodyPayloadForSensitiveValues(input) {
-    return scanPublicSafePayload(input, {
-        patterns: custodyStringPatterns,
-        isForbiddenFieldName: isForbiddenCustodyFieldName,
-        isPatternExempt: ({ reason, match }) => reason === "high_entropy_token" && isPlatformContentDigest(match)
-    });
-}
-export function assertPublicSafeCustodyPayload(input) {
-    const findings = scanCustodyPayloadForSensitiveValues(input);
-    if (findings.length > 0) {
-        throw new CustodyManifestRedactionError(findings);
-    }
-}
-function normalizeSession(input) {
-    return Object.freeze({
-        sessionId: assertSafeIdentifier(input.sessionId, "session.sessionId"),
-        workspaceId: assertSafeIdentifier(input.workspaceId, "session.workspaceId"),
-        provider: assertSafeMetadataString(input.provider, "session.provider"),
-        terminalStatus: assertSafeMetadataString(input.terminalStatus, "session.terminalStatus"),
-        ...(input.createdAt ? { createdAt: assertTimestamp(input.createdAt, "session.createdAt") } : {}),
-        ...(input.terminalAt ? { terminalAt: assertTimestamp(input.terminalAt, "session.terminalAt") } : {})
-    });
-}
-function normalizeSecretClass(input) {
-    const count = nonNegativeInteger(input.count ?? (input.present ? 1 : 0), "secret.count");
-    return Object.freeze({
-        class: assertSafeMetadataString(input.class, "secret.class"),
-        present: input.present,
-        count,
-        exposures: Object.freeze((input.exposures ?? []).map(normalizeExposure)),
-        disposition: normalizeDisposition(input.disposition),
-        ...(input.evidence ? { evidence: Object.freeze(input.evidence.map(normalizeEvidence)) } : {})
-    });
-}
-function normalizeResourceClass(input) {
-    const count = nonNegativeInteger(input.count ?? 1, "resource.count");
-    return Object.freeze({
-        class: assertSafeMetadataString(input.class, "resource.class"),
-        count,
-        exposures: Object.freeze((input.exposures ?? []).map(normalizeExposure)),
-        disposition: normalizeDisposition(input.disposition),
-        ...(input.evidence ? { evidence: Object.freeze(input.evidence.map(normalizeEvidence)) } : {})
-    });
-}
-function normalizeExposure(input) {
-    return Object.freeze({
-        surface: assertSafeMetadataString(input.surface, "exposure.surface"),
-        access: input.access,
-        ...(input.status ? { status: input.status } : {}),
-        ...(input.count !== undefined ? { count: nonNegativeInteger(input.count, "exposure.count") } : {}),
-        ...(input.firstExposedAt
-            ? { firstExposedAt: assertTimestamp(input.firstExposedAt, "exposure.firstExposedAt") }
-            : {}),
-        ...(input.lastExposedAt
-            ? { lastExposedAt: assertTimestamp(input.lastExposedAt, "exposure.lastExposedAt") }
-            : {}),
-        ...(input.revokedAt ? { revokedAt: assertTimestamp(input.revokedAt, "exposure.revokedAt") } : {})
-    });
-}
-function normalizeDisposition(input) {
-    return Object.freeze({
-        status: input.status,
-        ...(input.reason ? { reason: assertSafeMetadataString(input.reason, "disposition.reason") } : {}),
-        ...(input.decidedAt ? { decidedAt: assertTimestamp(input.decidedAt, "disposition.decidedAt") } : {}),
-        ...(input.errorClass ? { errorClass: assertSafeMetadataString(input.errorClass, "disposition.errorClass") } : {}),
-        ...(input.followUpRequired !== undefined ? { followUpRequired: input.followUpRequired } : {})
-    });
-}
-function normalizeEvidence(input) {
-    return Object.freeze({
-        source: assertSafeMetadataString(input.source, "evidence.source"),
-        ...(input.status ? { status: assertSafeMetadataString(input.status, "evidence.status") } : {}),
-        ...(input.observedAt ? { observedAt: assertTimestamp(input.observedAt, "evidence.observedAt") } : {}),
-        ...(input.count !== undefined ? { count: nonNegativeInteger(input.count, "evidence.count") } : {}),
-        ...(input.errorClass ? { errorClass: assertSafeMetadataString(input.errorClass, "evidence.errorClass") } : {})
-    });
-}
-function normalizeCleanup(input) {
-    if (!input) {
-        return Object.freeze({ status: "pending" });
-    }
-    return Object.freeze({
-        status: input.status,
-        ...(input.startedAt ? { startedAt: assertTimestamp(input.startedAt, "cleanup.startedAt") } : {}),
-        ...(input.finishedAt ? { finishedAt: assertTimestamp(input.finishedAt, "cleanup.finishedAt") } : {}),
-        ...(input.errorClass ? { errorClass: assertSafeMetadataString(input.errorClass, "cleanup.errorClass") } : {}),
-        ...(input.followUpRequiredCount !== undefined
-            ? {
-                followUpRequiredCount: nonNegativeInteger(input.followUpRequiredCount, "cleanup.followUpRequiredCount")
-            }
-            : {})
-    });
-}
-function buildCustodySummary(secrets, resources, cleanup) {
-    const records = [...secrets, ...resources];
-    const dispositionCounts = {};
-    let exposureCount = 0;
-    let revokedExposureCount = 0;
-    let followUpRequiredCount = cleanup.followUpRequiredCount ?? 0;
-    for (const record of records) {
-        dispositionCounts[record.disposition.status] = (dispositionCounts[record.disposition.status] ?? 0) + 1;
-        exposureCount += record.exposures.length;
-        revokedExposureCount += record.exposures.filter((exposure) => exposure.status === "revoked").length;
-        if (record.disposition.followUpRequired) {
-            followUpRequiredCount++;
-        }
-    }
-    return Object.freeze({
-        secretClassCount: secrets.length,
-        secretInstanceCount: secrets.reduce((sum, record) => sum + record.count, 0),
-        resourceClassCount: resources.length,
-        resourceInstanceCount: resources.reduce((sum, record) => sum + record.count, 0),
-        exposureCount,
-        revokedExposureCount,
-        retainedCount: dispositionCounts.retained_by_policy ?? 0,
-        cleanupFailedCount: dispositionCounts.cleanup_failed ?? 0,
-        parkedForOperatorCount: dispositionCounts.parked_for_operator ?? 0,
-        pendingCount: dispositionCounts.pending ?? 0,
-        followUpRequiredCount,
-        dispositionCounts: Object.freeze({ ...dispositionCounts })
-    });
-}
-function normalizeSummary(input) {
-    return Object.freeze({
-        secretClassCount: nonNegativeInteger(input.secretClassCount, "summary.secretClassCount"),
-        secretInstanceCount: nonNegativeInteger(input.secretInstanceCount, "summary.secretInstanceCount"),
-        resourceClassCount: nonNegativeInteger(input.resourceClassCount, "summary.resourceClassCount"),
-        resourceInstanceCount: nonNegativeInteger(input.resourceInstanceCount, "summary.resourceInstanceCount"),
-        exposureCount: nonNegativeInteger(input.exposureCount, "summary.exposureCount"),
-        revokedExposureCount: nonNegativeInteger(input.revokedExposureCount, "summary.revokedExposureCount"),
-        retainedCount: nonNegativeInteger(input.retainedCount, "summary.retainedCount"),
-        cleanupFailedCount: nonNegativeInteger(input.cleanupFailedCount, "summary.cleanupFailedCount"),
-        parkedForOperatorCount: nonNegativeInteger(input.parkedForOperatorCount, "summary.parkedForOperatorCount"),
-        pendingCount: nonNegativeInteger(input.pendingCount, "summary.pendingCount"),
-        followUpRequiredCount: nonNegativeInteger(input.followUpRequiredCount, "summary.followUpRequiredCount"),
-        dispositionCounts: Object.freeze(Object.fromEntries(Object.entries(input.dispositionCounts).map(([key, value]) => [
-            key,
-            nonNegativeInteger(value, `summary.dispositionCounts.${key}`)
-        ])))
-    });
-}
-const custodyStringPatterns = Object.freeze([
-    ...PUBLIC_SAFE_SECRET_PATTERNS,
-    privateResourceHandlePattern([
-        "machine",
-        "agent",
-        "resource",
-        "handle",
-        "token_hash",
-        "bearer_hash"
-    ])
-]);
-const isForbiddenCustodyFieldName = createForbiddenFieldNamePredicate([
-    "apiKey",
-    "apiKeys",
-    "secretValue",
-    "bearerHash",
-    "signedUrl",
-    "objectStoreKey",
-    "objectKey",
-    "vaultId",
-    "providerResponseBody",
-    "responseBody",
-    "privateResourceHandle",
-    "resourceHandle",
-    "rawBody"
-]);
-function assertSafeIdentifier(value, field) {
-    assertNonEmptyString(value, field);
-    if (!/^[A-Za-z0-9._:-]+$/.test(value)) {
-        throw new Error(`custody manifest ${field} must be an opaque identifier without path separators`);
-    }
-    assertPublicSafeCustodyPayload(value);
-    return value;
-}
-function assertSafeMetadataString(value, field) {
-    assertNonEmptyString(value, field);
-    assertPublicSafeCustodyPayload(value);
-    return value;
-}
-function assertNonEmptyString(value, field) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new Error(`custody manifest ${field} must be a non-empty string`);
-    }
-}
-function assertTimestamp(value, field) {
-    assertSafeMetadataString(value, field);
-    const ms = Date.parse(value);
-    if (!Number.isFinite(ms)) {
-        throw new Error(`custody manifest ${field} must be an ISO timestamp string`);
-    }
-    return value;
-}
-function nonNegativeInteger(value, field) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new Error(`custody manifest ${field} must be a non-negative safe integer`);
-    }
-    return value;
-}
-function formatFindingPaths(findings) {
-    return findings.map((finding) => `${finding.path} (${finding.reason})`).join(", ");
-}

package/dist/_contracts/session-file-query.d.ts

@@ -1,14 +0,0 @@
-import type { SessionFile, SessionFilePathSelector, SessionFileQuery, SessionFileSelector, SessionFileType } from "./runtime-types.js";
-/** Package-private path-selector guard shared by transport orchestration. */
-export declare function isPathSelector(selector: SessionFileSelector): selector is SessionFilePathSelector;
-export declare function resolveSessionFileSelector(files: readonly SessionFile[], selector: SessionFilePathSelector, sessionId?: string): SessionFile;
-export declare function filterSessionFiles(files: readonly SessionFile[], query: SessionFileQuery): readonly SessionFile[];
-/**
- * The single filename-matcher for cross-session / per-session file SEARCH. A
- * string is a case-insensitive SUBSTRING match; a RegExp is tested as given (and
- * reset to `lastIndex = 0` so a reused `/g` regex is safe). Sharing this SSoT is
- * what closes the T16 crash class: session-file search no longer assumes `filename`
- * is a string and passes a RegExp into `escapeRegExp(...).replace(...)`.
- */
-export declare function toFilenameMatcher(filename: string | RegExp): (name: string) => boolean;
-export declare function classifySessionFile(file: Pick<SessionFile, "filename" | "contentType">): SessionFileType;