@tiangong-lca/cli 0.1.1 → 0.1.2

package/dist/src/lib/dataset-maintenance-protected-before.d.ts

@@ -0,0 +1,71 @@
+import { type DatasetMaintenancePlan, type DatasetMaintenanceRemoteRow, type DatasetMaintenanceRowSnapshot } from './dataset-maintenance-contract.js';
+import { parseProtectedDerivativeSnapshot, type ProtectedDerivativeSnapshot, type ProtectedDerivativeTarget } from './dataset-maintenance-protected-contract.js';
+import { fetchMaintenanceDerivativeSnapshot, fetchMaintenanceExactRows, type DatasetMaintenanceRemoteContext } from './dataset-maintenance-remote.js';
+export type ProtectedDerivativeSnapshotTarget = Omit<ProtectedDerivativeTarget, 'baseline_snapshot_sha256'> & {
+    baseline_snapshot_sha256?: string;
+};
+export type ProtectedBeforeReadDependencies = {
+    fetchExactRows: typeof fetchMaintenanceExactRows;
+    fetchDerivativeSnapshot: typeof fetchMaintenanceDerivativeSnapshot;
+    parseDerivativeSnapshot: typeof parseProtectedDerivativeSnapshot;
+};
+export type ProtectedBeforeReadDependencyOverrides = Partial<ProtectedBeforeReadDependencies>;
+export type ProtectedBeforeValidationResult = {
+    projected_rows: DatasetMaintenanceRemoteRow[];
+    support_snapshots: DatasetMaintenanceRowSnapshot[];
+    derivative_snapshots: ProtectedDerivativeSnapshot[];
+    derivative_mode: 'capture' | 'compare';
+};
+type ProtectedBeforeBaseOptions = {
+    plan: DatasetMaintenancePlan;
+    planDir: string;
+    actorUserId: string;
+    currentRows: DatasetMaintenanceRemoteRow[];
+    completeness: unknown;
+    context: DatasetMaintenanceRemoteContext;
+    dependencies?: ProtectedBeforeReadDependencyOverrides;
+};
+export type ValidateProtectedBeforeStateOptions = ProtectedBeforeBaseOptions & ({
+    derivativeMode: 'capture';
+    derivativeTargets: ProtectedDerivativeSnapshotTarget[];
+} | {
+    derivativeMode: 'compare';
+    derivativeTargets: ProtectedDerivativeTarget[];
+});
+export declare function projectedRows(options: {
+    plan: DatasetMaintenancePlan;
+    planDir: string;
+    currentRows: DatasetMaintenanceRemoteRow[];
+}): DatasetMaintenanceRemoteRow[];
+export declare function assertStrictBeforeState(options: {
+    plan: DatasetMaintenancePlan;
+    planDir: string;
+    actorUserId: string;
+    currentRows: DatasetMaintenanceRemoteRow[];
+    completeness: unknown;
+}): DatasetMaintenanceRemoteRow[];
+export declare function assertSupportSnapshots(options: {
+    plan: DatasetMaintenancePlan;
+    actorUserId: string;
+    context: DatasetMaintenanceRemoteContext;
+    dependencies?: ProtectedBeforeReadDependencyOverrides;
+}): Promise<DatasetMaintenanceRowSnapshot[]>;
+export declare function captureDerivativeSnapshots(options: {
+    actorUserId: string;
+    context: DatasetMaintenanceRemoteContext;
+    derivativeTargets: ProtectedDerivativeSnapshotTarget[];
+    dependencies?: ProtectedBeforeReadDependencyOverrides;
+}): Promise<ProtectedDerivativeSnapshot[]>;
+export declare function assertDerivativeBaselines(options: {
+    actorUserId: string;
+    context: DatasetMaintenanceRemoteContext;
+    derivativeTargets: ProtectedDerivativeTarget[];
+    dependencies?: ProtectedBeforeReadDependencyOverrides;
+}): Promise<ProtectedDerivativeSnapshot[]>;
+export declare function assertDerivativeCensusBindings(options: {
+    actorUserId: string;
+    currentRows: DatasetMaintenanceRemoteRow[];
+    derivativeSnapshots: ProtectedDerivativeSnapshot[];
+}): void;
+export declare function validateProtectedBeforeState(options: ValidateProtectedBeforeStateOptions): Promise<ProtectedBeforeValidationResult>;
+export {};

package/dist/src/lib/dataset-maintenance-protected-contract.d.ts

@@ -0,0 +1,385 @@
+import { type DatasetMaintenancePlan, type JsonObject } from './dataset-maintenance-contract.js';
+export declare const PROTECTED_EXECUTION_CONTRACT: {
+    readonly freeze_schema: 'dataset-alias-execution-freeze.v1';
+    readonly approval_schema: 'dataset-alias-execution-approval.v1';
+    readonly preflight_request_schema: 'dataset-alias-execution-preflight.v1';
+    readonly preflight_response_schema: 'dataset-alias-execution-preflight-proof.v1';
+    readonly gate_response_schema: 'dataset-alias-execution-gate-receipt.v1';
+    readonly admit_request_schema: 'dataset-alias-execution-admit.v1';
+    readonly admit_response_schema: 'dataset-alias-execution-admit.v1';
+    readonly status_response_schema: 'dataset-alias-execution-status.v1';
+    readonly terminal_proof_schema: 'dataset-alias-execution-terminal-proof.v1';
+    readonly marker_schema: 'dataset-alias-execution-attempt.v1';
+    readonly report_schema: 'dataset-alias-execution-report.v1';
+    readonly preflight_command: 'cmd_dataset_alias_execution_preflight_guarded';
+    readonly gate_command: 'cmd_dataset_alias_execution_gate_guarded';
+    readonly admit_command: 'cmd_dataset_alias_execution_admit_guarded';
+    readonly read_command: 'cmd_dataset_alias_execution_read';
+};
+export declare const PROTECTED_EXECUTION_COUNTS: {
+    readonly action_count: 52;
+    readonly batch_count: 2;
+    readonly exchange_count: 59;
+    readonly amount_field_count: 118;
+    readonly unrelated_exchange_count: 309;
+    readonly audit_count: 55;
+    readonly flowproperty_count: 2;
+    readonly flow_count: 23;
+    readonly process_count: 27;
+    readonly derivative_target_count: 50;
+};
+export type ProtectedExecutionStatus = 'not_admitted' | 'dispatching' | 'dispatched' | 'running' | 'derivatives_pending' | 'completed' | 'failed' | 'indeterminate';
+export type ProtectedReportStatus = 'pending' | 'passed' | 'failed' | 'indeterminate';
+export type ProtectedDerivativeTargetTable = 'flows' | 'processes';
+export type ProtectedDerivativeTarget = {
+    table: ProtectedDerivativeTargetTable;
+    id: string;
+    version: string;
+    user_id: string;
+    state_code: 0;
+    baseline_snapshot_sha256: string;
+};
+export type ProtectedDerivativeSnapshot = {
+    schema_version: 'dataset-derivative-snapshot.v1';
+    table: ProtectedDerivativeTargetTable;
+    id: string;
+    version: string;
+    user_id: string;
+    state_code: 0;
+    modified_at: string;
+    json_sha256: string;
+    json_ordered_sha256: string;
+    extracted_md_sha256: string | null;
+    embedding_ft_sha256: string | null;
+    embedding_ft_at: string | null;
+    snapshot_sha256: string;
+};
+export type ProtectedExecutionBindings = {
+    plan_file_sha256: string;
+    freeze_file_sha256: string;
+    freeze_sha256: string;
+    approval_file_sha256: string;
+    approval_identity_sha256: string;
+    approval_text_sha256: string;
+    alias_plan_request_sha256: string;
+    before_hash_set_sha256: string;
+    desired_hash_set_sha256: string;
+    exchange_rewrite_set_sha256: string;
+    support_snapshot_set_sha256: string;
+    derivative_baseline_set_sha256: string;
+    derivative_target_set_sha256: string;
+    toolchain_evidence_sha256: string;
+};
+export type ProtectedGateExpectations = {
+    primary_support_plan_sha256: string;
+    execution_unused_sha256: string;
+    derivative_quiescence_sha256: string;
+};
+export type DatasetMaintenanceProtectedFreeze = {
+    schema_version: typeof PROTECTED_EXECUTION_CONTRACT.freeze_schema;
+    environment: 'production';
+    project_ref: string;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    target_visibility: 'owner_draft';
+    plan: {
+        plan_file_sha256: string;
+        plan_sha256: string;
+        operation_id: string;
+    };
+    sets: Omit<ProtectedExecutionBindings, 'plan_file_sha256' | 'freeze_file_sha256' | 'freeze_sha256' | 'approval_file_sha256' | 'approval_identity_sha256' | 'approval_text_sha256'>;
+    expected: typeof PROTECTED_EXECUTION_COUNTS;
+    derivative_targets: ProtectedDerivativeTarget[];
+    policy: {
+        state_code_changes: 0;
+        save_draft: 0;
+        deletes: 0;
+        rebuild_derivatives: 0;
+        unitgroup_actions: 0;
+        person_distance_actions: 0;
+        max_admit_posts: 1;
+        automatic_retry: false;
+    };
+    freeze_sha256: string;
+};
+export type DatasetMaintenanceProtectedApproval = {
+    schema_version: typeof PROTECTED_EXECUTION_CONTRACT.approval_schema;
+    approved_at_utc: string;
+    environment: 'production';
+    project_ref: string;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    target_visibility: 'owner_draft';
+    plan_sha256: string;
+    operation_id: string;
+    plan_file_sha256: string;
+    freeze_file_sha256: string;
+    freeze_sha256: string;
+    approval_text_sha256: string;
+    max_admit_posts: 1;
+    automatic_retry: false;
+    approval_identity_sha256: string;
+};
+export type ProtectedExecutionIdentity = {
+    request_id: string;
+    identity_sha256: string;
+    environment: 'production';
+    project_ref: string;
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    target_visibility: 'owner_draft';
+    plan_sha256: string;
+    operation_id: string;
+    bindings: ProtectedExecutionBindings;
+    expected: typeof PROTECTED_EXECUTION_COUNTS;
+    derivative_targets: ProtectedDerivativeTarget[];
+};
+export type ProtectedPreflightProof = {
+    schema_version: typeof PROTECTED_EXECUTION_CONTRACT.preflight_response_schema;
+    command: typeof PROTECTED_EXECUTION_CONTRACT.preflight_command;
+    request_id: string;
+    actor_user_id: string;
+    environment: 'production';
+    project_ref: string;
+    server_context_sha256: string;
+    plan_sha256: string;
+    operation_id: string;
+    alias_plan_request_sha256: string;
+    freeze_sha256: string;
+    approval_identity_sha256: string;
+    plan_request_sha256: string;
+    bindings_sha256: string;
+    expected_sha256: string;
+    derivative_targets_sha256: string;
+    gate_expectations: ProtectedGateExpectations;
+    gate_expectations_sha256: string;
+    failure_baseline_sha256: string;
+    preflight_request_sha256: string;
+    preflight_token: string;
+    preflight_proof_sha256: string;
+    completed_at: string;
+    expires_at: string;
+    simulation: {
+        plan_rows: 52;
+        plan_exchanges: 59;
+        alias_audits: 55;
+        derivative_targets: 50;
+        rolled_back: true;
+    };
+};
+export type ProtectedGateResult = {
+    expected_sha256: string;
+    observed_sha256: string;
+    status: 'passed';
+    captured_at: string;
+};
+export type ProtectedGateProof = {
+    schema_version: typeof PROTECTED_EXECUTION_CONTRACT.gate_response_schema;
+    command: typeof PROTECTED_EXECUTION_CONTRACT.gate_command;
+    request_id: string;
+    actor_user_id: string;
+    preflight_proof_sha256: string;
+    gate: 'primary_support_plan' | 'execution_unused' | 'derivative_quiescence';
+    result: ProtectedGateResult;
+    receipt_sha256: string;
+};
+export type ProtectedAdmissionProof = {
+    schema_version: typeof PROTECTED_EXECUTION_CONTRACT.admit_response_schema;
+    command: typeof PROTECTED_EXECUTION_CONTRACT.admit_command;
+    request_id: string;
+    plan_sha256: string;
+    operation_id: string;
+    plan_request_sha256: string;
+    preflight_proof_sha256: string;
+    admission_request_sha256: string;
+    gate_results_sha256: string;
+    status: 'dispatched';
+    attempt_count: 1;
+    dispatch_count: 1;
+    net_request_id: string;
+    attempt_consumed: true;
+    retry_allowed: false;
+};
+export type ProtectedTerminalTargetProof = {
+    ordinal: number;
+    request_id: string;
+    table: ProtectedDerivativeTargetTable;
+    id: string;
+    version: string;
+    status: string;
+    phase: string;
+    source_baseline_snapshot_sha256: string;
+    expected_snapshot_sha256: string;
+    completed_snapshot_sha256: string | null;
+    primary_matches: boolean;
+    terminal_snapshot_matches: boolean;
+    proposals_committed: boolean;
+    derivative_fresh: boolean;
+    lifecycle_complete: boolean;
+    terminal_audit_present: boolean;
+    residue: {
+        http_requests: number;
+        embedding_jobs: number;
+        pending_jobs: number;
+        failure_rows: number;
+        other_active_fences: number;
+    };
+    causal_terminal_proof: boolean;
+};
+export type ProtectedStatusTargetProof = {
+    ordinal: number;
+    request_id: string;
+    table: ProtectedDerivativeTargetTable;
+    id: string;
+    version: string;
+    status: string;
+    phase: string;
+    error: JsonObject | null;
+    causal_terminal_proof: false;
+};
+type ProtectedDerivativeReadbackCommon = {
+    schema_version: 'dataset-derivative-rebuild-batch-status.v1';
+    batch_id: string;
+    code: string | null;
+    causal_terminal_proof: boolean;
+    target_count: number;
+    flow_count: number;
+    process_count: number;
+    completed_count: number;
+    nonterminal_count: number;
+    failed_count: number;
+};
+export type ProtectedDerivativeReadback = ProtectedDerivativeReadbackCommon & ({
+    status: 'not_started';
+    proof_level: 'none';
+    proof_deferred: false;
+    invalid_proof_count: null;
+    targets: [];
+} | {
+    status: 'pending' | 'failed';
+    proof_level: 'status_only';
+    proof_deferred: boolean;
+    invalid_proof_count: null;
+    targets: ProtectedStatusTargetProof[];
+} | {
+    status: 'completed' | 'failed';
+    proof_level: 'causal_terminal';
+    proof_deferred: false;
+    invalid_proof_count: number;
+    targets: ProtectedTerminalTargetProof[];
+});
+export type ProtectedExecutionStatusProof = {
+    schema_version: typeof PROTECTED_EXECUTION_CONTRACT.status_response_schema;
+    command: typeof PROTECTED_EXECUTION_CONTRACT.read_command;
+    request_id: string;
+    status: ProtectedReportStatus;
+    execution_status: ProtectedExecutionStatus;
+    retry_allowed: false;
+    actor_user_id: string;
+    environment: 'production';
+    project_ref: string;
+    target_visibility: 'owner_draft' | null;
+    plan_sha256: string;
+    operation_id: string;
+    plan_request_sha256: string;
+    freeze_sha256: string | null;
+    approval_identity_sha256: string | null;
+    approval_text_sha256: string | null;
+    derivative_target_set_sha256: string | null;
+    preflight_proof_sha256: string;
+    admission_request_sha256: string | null;
+    gate_results_sha256: string | null;
+    attempt_count: number;
+    dispatch_count: number;
+    gate_count: number;
+    gates: Array<ProtectedGateResult & {
+        gate: ProtectedGateProof['gate'];
+        receipt_sha256: string;
+    }>;
+    primary_readback: {
+        row_count: number | null;
+        exchange_count: number | null;
+        alias_audit_count: number;
+        live_closure_proof: boolean;
+        closure: JsonObject;
+    } | null;
+    derivative_readback: ProtectedDerivativeReadback;
+    failure: JsonObject | null;
+};
+declare function parseExpected(value: unknown): typeof PROTECTED_EXECUTION_COUNTS;
+declare function parseDerivativeTarget(value: unknown, index: number): ProtectedDerivativeTarget;
+export declare function parseProtectedDerivativeSnapshot(value: unknown, expected: {
+    table: ProtectedDerivativeTargetTable;
+    id: string;
+    version: string;
+    userId: string;
+}): ProtectedDerivativeSnapshot;
+export declare function computeProtectedFreezeSha256(freeze: DatasetMaintenanceProtectedFreeze): string;
+export declare function parseProtectedFreeze(value: unknown): DatasetMaintenanceProtectedFreeze;
+export declare function computeProtectedApprovalIdentitySha256(approval: DatasetMaintenanceProtectedApproval): string;
+export declare function parseProtectedApproval(value: unknown): DatasetMaintenanceProtectedApproval;
+export declare function protectedPlanSetHashes(plan: DatasetMaintenancePlan): {
+    before_hash_set_sha256: string;
+    desired_hash_set_sha256: string;
+    exchange_rewrite_set_sha256: string;
+    support_snapshot_set_sha256: string;
+    derivative_target_set_sha256: string;
+};
+export declare function protectedDerivativeBaselineSetSha256(targets: ProtectedDerivativeTarget[]): string;
+export declare function assertProtectedFreezeMatchesPlan(options: {
+    plan: DatasetMaintenancePlan;
+    planFileSha256: string;
+    aliasPlanRequestSha256: string;
+    freeze: DatasetMaintenanceProtectedFreeze;
+}): void;
+export declare function assertProtectedApprovalBindings(options: {
+    approval: DatasetMaintenanceProtectedApproval;
+    freeze: DatasetMaintenanceProtectedFreeze;
+    freezeFileSha256: string;
+    approvalFileSha256: string;
+    approveExecution?: string;
+}): void;
+declare function deterministicUuidFromSha256(digest: string): string;
+export declare function buildProtectedExecutionIdentity(options: {
+    freeze: DatasetMaintenanceProtectedFreeze;
+    approval: DatasetMaintenanceProtectedApproval;
+    freezeFileSha256: string;
+    approvalFileSha256: string;
+}): ProtectedExecutionIdentity;
+export declare function buildProtectedPreflightRequest(options: {
+    identity: ProtectedExecutionIdentity;
+    plan: JsonObject;
+    freeze: DatasetMaintenanceProtectedFreeze;
+    approval: DatasetMaintenanceProtectedApproval;
+}): JsonObject;
+export declare function parseProtectedPreflightProof(value: unknown, identity: ProtectedExecutionIdentity, now?: Date): ProtectedPreflightProof;
+export declare function parseProtectedGateProof(value: unknown, options: {
+    identity: ProtectedExecutionIdentity;
+    preflight: ProtectedPreflightProof;
+    gate: ProtectedGateProof['gate'];
+}): ProtectedGateProof;
+export declare function buildProtectedAdmitRequest(options: {
+    preflight: ProtectedPreflightProof;
+    gateResults: {
+        primary_support_plan: ProtectedGateResult;
+        execution_unused: ProtectedGateResult;
+        derivative_quiescence: ProtectedGateResult;
+    };
+}): JsonObject;
+export declare function parseProtectedAdmissionProof(value: unknown, identity: ProtectedExecutionIdentity, preflight: ProtectedPreflightProof): ProtectedAdmissionProof;
+declare function parseBindings(value: unknown): ProtectedExecutionBindings;
+export declare function parseProtectedStatusProof(value: unknown, identity: ProtectedExecutionIdentity): ProtectedExecutionStatusProof;
+export declare function isUuid(value: string): boolean;
+export declare const __testInternals: {
+    deterministicUuidFromSha256: typeof deterministicUuidFromSha256;
+    parseBindings: typeof parseBindings;
+    parseDerivativeTarget: typeof parseDerivativeTarget;
+    parseExpected: typeof parseExpected;
+};
+export {};

package/dist/src/lib/dataset-maintenance-protected-freeze.d.ts

@@ -0,0 +1,148 @@
+import { buildAliasPlanRequest } from './dataset-maintenance-alias-request.js';
+import { readProtectedJsonArtifact, materializePrivateArtifactDirectoryAtomically, writePrivateImmutableJson, writePrivateImmutableText } from './dataset-maintenance-protected-artifacts.js';
+import { validateProtectedBeforeState, type ProtectedBeforeValidationResult } from './dataset-maintenance-protected-before.js';
+import { parseMaintenancePlan, type DatasetMaintenancePlan } from './dataset-maintenance-contract.js';
+import { PROTECTED_EXECUTION_COUNTS, type ProtectedDerivativeSnapshot } from './dataset-maintenance-protected-contract.js';
+import { buildProtectedApprovalRequest, buildProtectedFreeze, deriveProtectedDerivativeSnapshotTargets } from './dataset-maintenance-protected-preparation.js';
+import { fetchMaintenanceAccountRows, resolveMaintenanceRemoteContext, type DatasetMaintenanceRemoteContext } from './dataset-maintenance-remote.js';
+import { parseProtectedToolchainEvidence, type DatasetMaintenanceProtectedToolchainEvidence } from './dataset-maintenance-protected-toolchain.js';
+import type { FetchLike } from './http.js';
+export declare const PROTECTED_FREEZE_ARTIFACTS: {
+    readonly alias_plan_request: 'protected-alias-plan-request.json';
+    readonly derivative_baselines: 'protected-derivative-baselines.json';
+    readonly freeze: 'protected-execution-freeze.json';
+    readonly approval_request: 'protected-approval-request.json';
+    readonly approval_text: 'protected-approval-request.txt';
+    readonly report: 'protected-freeze-report.json';
+};
+export type FreezeDatasetMaintenanceProtectedOptions = {
+    planPath: string;
+    toolchainEvidencePath: string;
+    outDir: string;
+    expectedProjectRef: string;
+    confirm: string;
+    cliVersion: string;
+    pageSize?: number;
+    timeoutMs?: number;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    now?: Date;
+};
+export type DatasetMaintenanceProtectedBaselineManifest = {
+    schema_version: 'dataset-alias-derivative-baselines.v1';
+    environment: 'production';
+    project_ref: string;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    plan: {
+        plan_sha256: string;
+        operation_id: string;
+    };
+    target_count: 50;
+    flow_count: 23;
+    process_count: 27;
+    derivative_baseline_set_sha256: string;
+    derivative_snapshot_set_sha256: string;
+    snapshots: ProtectedDerivativeSnapshot[];
+};
+export type DatasetMaintenanceProtectedFreezeReport = {
+    schema_version: 'dataset-alias-protected-freeze-report.v1';
+    generated_at_utc: string;
+    status: 'ready_for_human_approval';
+    remote_write_mode: 'read_only';
+    environment: 'production';
+    project_ref: string;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    plan_sha256: string;
+    operation_id: string;
+    freeze_sha256: string;
+    approval_request_sha256: string;
+    approval_text_sha256: string;
+    toolchain_evidence_sha256: string;
+    derivative_baseline_set_sha256: string;
+    derivative_snapshot_set_sha256: string;
+    counts: typeof PROTECTED_EXECUTION_COUNTS;
+    assertions: {
+        account_census_complete: true;
+        strict_before_state: true;
+        projected_reference_closure: true;
+        support_snapshots: 6;
+        derivative_snapshots: 50;
+        preflight_calls: 0;
+        gate_calls: 0;
+        admission_calls: 0;
+        mutation_calls: 0;
+        approval_artifacts: 0;
+    };
+    artifacts: {
+        alias_plan_request: string;
+        derivative_baselines: string;
+        freeze: string;
+        approval_request: string;
+        approval_text: string;
+        report: string;
+    };
+    artifact_sha256: {
+        alias_plan_request: string;
+        derivative_baselines: string;
+        freeze: string;
+        approval_request: string;
+        approval_text: string;
+        report: null;
+    };
+};
+type FreezeProtectedDependencies = {
+    readArtifact: typeof readProtectedJsonArtifact;
+    parsePlan: typeof parseMaintenancePlan;
+    buildAliasPlan: typeof buildAliasPlanRequest;
+    resolveContext: typeof resolveMaintenanceRemoteContext;
+    fetchAccountRows: typeof fetchMaintenanceAccountRows;
+    parseToolchain: typeof parseProtectedToolchainEvidence;
+    deriveTargets: typeof deriveProtectedDerivativeSnapshotTargets;
+    validateBefore: typeof validateProtectedBeforeState;
+    buildFreeze: typeof buildProtectedFreeze;
+    buildApprovalRequest: typeof buildProtectedApprovalRequest;
+    writeJson: typeof writePrivateImmutableJson;
+    writeText: typeof writePrivateImmutableText;
+    materializeArtifacts: typeof materializePrivateArtifactDirectoryAtomically;
+};
+declare function requiredToken(value: string, label: string): string;
+declare function assertContext(options: {
+    context: DatasetMaintenanceRemoteContext;
+    plan: DatasetMaintenancePlan;
+    expectedProjectRef: string;
+    confirm: string;
+}): {
+    user_id: string;
+    email: string;
+};
+declare function assertCanonicalToolchainArtifact(options: {
+    artifactText: string;
+    evidence: DatasetMaintenanceProtectedToolchainEvidence;
+}): void;
+declare function artifactPaths(outDir: string): DatasetMaintenanceProtectedFreezeReport['artifacts'];
+declare function buildBaselineManifest(options: {
+    context: DatasetMaintenanceRemoteContext;
+    plan: DatasetMaintenancePlan;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    validation: ProtectedBeforeValidationResult;
+    derivativeBaselineSetSha256: string;
+}): DatasetMaintenanceProtectedBaselineManifest;
+export declare function freezeDatasetMaintenanceProtected(options: FreezeDatasetMaintenanceProtectedOptions, dependencies?: FreezeProtectedDependencies): Promise<DatasetMaintenanceProtectedFreezeReport>;
+export declare const __testInternals: {
+    artifactPaths: typeof artifactPaths;
+    assertCanonicalToolchainArtifact: typeof assertCanonicalToolchainArtifact;
+    assertContext: typeof assertContext;
+    buildBaselineManifest: typeof buildBaselineManifest;
+    DEFAULT_FREEZE_DEPENDENCIES: FreezeProtectedDependencies;
+    requiredToken: typeof requiredToken;
+};
+export {};

package/dist/src/lib/dataset-maintenance-protected-preparation.d.ts

@@ -0,0 +1,76 @@
+import { type DatasetMaintenancePlan, type JsonObject } from './dataset-maintenance-contract.js';
+import { PROTECTED_EXECUTION_COUNTS, type DatasetMaintenanceProtectedApproval, type DatasetMaintenanceProtectedFreeze, type ProtectedDerivativeSnapshot, type ProtectedDerivativeTarget } from './dataset-maintenance-protected-contract.js';
+export declare const PROTECTED_PREPARATION_CONTRACT: {
+    readonly approval_request_schema: 'dataset-alias-execution-approval-request.v1';
+};
+export declare const PROTECTED_PRODUCTION_PROJECT_REF: 'qgzvkongdjqiiamzbbts';
+export declare const PROTECTED_PREPARATION_REJECTED_PLAN_SHA256: readonly ['813a201ded0443c79639cfbdb8f5a2fad8a8781ef6edd3ec7019e9a45f5f33ce', '673331422e8dceeb7975984b07276f057b37e8d6de789d7f030ec29f3be29629', '7fdf7e2755599d426e31a9955985d54d5b7cef1adeaa7a10dcc7186353a6c3a8'];
+type ProtectedApprovalRequestCore = {
+    schema_version: typeof PROTECTED_PREPARATION_CONTRACT.approval_request_schema;
+    approved_at_utc: string;
+    environment: 'production';
+    project_ref: string;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    target_visibility: 'owner_draft';
+    plan: DatasetMaintenanceProtectedFreeze['plan'];
+    freeze_file_sha256: string;
+    freeze_sha256: string;
+    sets: DatasetMaintenanceProtectedFreeze['sets'];
+    expected: typeof PROTECTED_EXECUTION_COUNTS;
+    policy: DatasetMaintenanceProtectedFreeze['policy'];
+};
+export type DatasetMaintenanceProtectedApprovalRequest = ProtectedApprovalRequestCore & {
+    request_sha256: string;
+    approval_text: string;
+    approval_text_sha256: string;
+};
+export type CanonicalProtectedArtifact<T> = {
+    value: T;
+    canonical_file_text: string;
+    file_sha256: string;
+};
+export type BuiltProtectedFreeze = CanonicalProtectedArtifact<DatasetMaintenanceProtectedFreeze> & {
+    alias_plan_request_sha256: string;
+};
+export type BuiltProtectedApprovalRequest = CanonicalProtectedArtifact<DatasetMaintenanceProtectedApprovalRequest>;
+export type BuiltProtectedApproval = CanonicalProtectedArtifact<DatasetMaintenanceProtectedApproval>;
+export type ProtectedDerivativeSnapshotTarget = Omit<ProtectedDerivativeTarget, 'baseline_snapshot_sha256'>;
+export declare function assertProtectedPreparationPlanSha256(value: unknown, label?: string): string;
+export declare function assertProtectedProductionProjectRef(value: unknown): string;
+export declare function renderProtectedApprovalText(core: ProtectedApprovalRequestCore, requestSha256: string): string;
+export declare function parseProtectedApprovalRequest(value: unknown): DatasetMaintenanceProtectedApprovalRequest;
+export declare function deriveProtectedDerivativeSnapshotTargets(plan: DatasetMaintenancePlan, expectedAccount: {
+    user_id: string;
+    email: string;
+}): ProtectedDerivativeSnapshotTarget[];
+export declare function buildProtectedFreeze(options: {
+    plan: DatasetMaintenancePlan;
+    planFileSha256: string;
+    aliasPlanRequest: JsonObject;
+    projectRef: string;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    toolchainEvidenceSha256: string;
+    derivativeSnapshots: ProtectedDerivativeSnapshot[];
+}): BuiltProtectedFreeze;
+export declare function buildProtectedApprovalRequest(options: {
+    freeze: DatasetMaintenanceProtectedFreeze;
+    freezeFileSha256: string;
+    approvedAtUtc: string;
+}): BuiltProtectedApprovalRequest;
+export declare function sealProtectedApproval(options: {
+    approvalRequest: unknown;
+    freeze: DatasetMaintenanceProtectedFreeze;
+    freezeFileSha256: string;
+    humanApprovalText: string;
+    approveRequestSha256: string;
+    approveTextSha256: string;
+    approvedAtUtc: string;
+    confirmAccountEmail: string;
+}): BuiltProtectedApproval;
+export {};