@oscharko-dev/keiko-contracts 0.2.8 → 0.2.9

package/dist/git-delivery-action-sheet.js

@@ -0,0 +1,430 @@
+// UI-safe approval and preview contracts for the governed Git delivery surface (Issue #473,
+// Epic #470). Ownership: git-delivery-action-sheet domain — the presentation projection that turns
+// the kernel's content-free facts (the #471 contract envelope + #472 lifecycle outputs) into a
+// consistent, UI-safe action sheet. Disjoint from git-delivery.ts (action model + risk + envelope),
+// git-delivery-policy.ts (policy evaluator), and git-delivery-provider.ts (provider-neutral state).
+//
+// Leaf-package rules (ADR-0019, ADR-0060): pure types and frozen const tables and pure functions
+// only. No IO, no clock, no crypto, no randomness. Relative imports end in ".js" and reference only
+// the git-delivery sibling atoms — never a kernel (keiko-tools) type. The kernel's preflight finding
+// codes are a keiko-tools concern; they reach this layer only as opaque, closed-vocabulary display
+// keys (GitDeliveryExpectedBlocker.reasonCode), never as a type this leaf re-enumerates. All
+// behavioural meaning is carried by typed fields (source/severity/remediation/cause/state), never
+// inferred from a string — satisfying the issue's Engineering Note.
+//
+// This module is content-free: it carries counts, flags, branch names, and typed codes only. It
+// never carries diff content, file paths, secrets, command strings, or raw subprocess output.
+import { GIT_DELIVERY_RISK_CLASS_SEVERITY, gitDeliveryRiskClassForInputs, isGitDeliveryActionKind, isGitDeliveryBlockReason, isGitDeliveryConstraint, isGitDeliveryRecoveryStrategyHint, isGitDeliveryRiskClass, } from "./git-delivery.js";
+import { isGitDeliveryBranchProtection, isGitDeliveryChecksState, isGitDeliveryMergeReadiness, isGitDeliveryPullRequestState, } from "./git-delivery-provider.js";
+export const GIT_DELIVERY_ACTION_SHEET_SCHEMA_VERSION = "1";
+export const GIT_DELIVERY_ACTION_SHEET_STATES = [
+    "ready-to-execute",
+    "waiting-for-approval",
+    "blocked",
+];
+export const GIT_DELIVERY_APPROVAL_NECESSITIES = [
+    "not-required",
+    "required",
+    "impossible",
+];
+export const GIT_DELIVERY_BLOCKED_CAUSES = [
+    "policy",
+    "preflight",
+    "provider-not-ready",
+];
+export const GIT_DELIVERY_BLOCKER_SOURCES = [
+    "preflight",
+    "policy",
+    "provider",
+];
+export const GIT_DELIVERY_BLOCKER_SEVERITIES = [
+    "blocking",
+    "advisory",
+];
+export const GIT_DELIVERY_REMEDIATION_CLASSES = [
+    "user-actionable",
+    "internal",
+];
+export const GIT_DELIVERY_RECOVERY_ACTION_HINTS = [
+    "retry",
+    "stage-changes",
+    "configure-upstream",
+    "resolve-conflicts",
+    "abort-in-progress-operation",
+    "request-approval",
+    "adjust-policy-target",
+    "recover-via-strategy",
+    "wait-for-provider",
+];
+// ─── Private predicate helpers ───────────────────────────────────────────────────────
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+function isNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(isString);
+}
+function isUndefinedOr(check) {
+    return (v) => v === undefined || check(v);
+}
+function isInSet(set) {
+    return (v) => isString(v) && set.includes(v);
+}
+// ─── Exported enum guards ────────────────────────────────────────────────────────────
+export const isGitDeliveryActionSheetState = isInSet(GIT_DELIVERY_ACTION_SHEET_STATES);
+export const isGitDeliveryApprovalNecessity = isInSet(GIT_DELIVERY_APPROVAL_NECESSITIES);
+export const isGitDeliveryBlockedCause = isInSet(GIT_DELIVERY_BLOCKED_CAUSES);
+export const isGitDeliveryBlockerSource = isInSet(GIT_DELIVERY_BLOCKER_SOURCES);
+export const isGitDeliveryBlockerSeverity = isInSet(GIT_DELIVERY_BLOCKER_SEVERITIES);
+export const isGitDeliveryRemediationClass = isInSet(GIT_DELIVERY_REMEDIATION_CLASSES);
+export const isGitDeliveryRecoveryActionHint = isInSet(GIT_DELIVERY_RECOVERY_ACTION_HINTS);
+// ─── Exported structural guards ──────────────────────────────────────────────────────
+export function isGitDeliveryExpectedBlocker(value) {
+    return (isRecord(value) &&
+        isGitDeliveryBlockerSource(value.source) &&
+        isGitDeliveryBlockerSeverity(value.severity) &&
+        isGitDeliveryRemediationClass(value.remediation) &&
+        isNonEmptyString(value.reasonCode));
+}
+export function isGitDeliveryRecoveryHint(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (!isGitDeliveryRecoveryActionHint(value.actionHint)) {
+        return false;
+    }
+    if (!isGitDeliveryRemediationClass(value.remediation)) {
+        return false;
+    }
+    if (!isUndefinedOr(isGitDeliveryRecoveryStrategyHint)(value.suggestedRecoveryStrategy)) {
+        return false;
+    }
+    // A concrete strategy is only meaningful for the "recover-via-strategy" hint.
+    if (value.suggestedRecoveryStrategy !== undefined &&
+        value.actionHint !== "recover-via-strategy") {
+        return false;
+    }
+    return true;
+}
+export function isGitDeliveryApprovalSummary(value) {
+    return (isRecord(value) &&
+        isGitDeliveryApprovalNecessity(value.necessity) &&
+        isBoolean(value.satisfied) &&
+        isGitDeliveryRiskClass(value.riskClass) &&
+        isNonNegativeInteger(value.riskSeverity) &&
+        isStringArray(value.requiredApprovers));
+}
+export const GIT_DELIVERY_POLICY_DECISION_OUTCOMES = ["allowed", "blocked", "approval-gated", "constrained"];
+export const isGitDeliveryPolicyDecisionOutcome = isInSet(GIT_DELIVERY_POLICY_DECISION_OUTCOMES);
+export function isGitDeliveryPolicyExplanation(value) {
+    return (isRecord(value) &&
+        isGitDeliveryPolicyDecisionOutcome(value.decision) &&
+        isStringArray(value.requiredApprovers) &&
+        Array.isArray(value.constraints) &&
+        value.constraints.every(isGitDeliveryConstraint) &&
+        isUndefinedOr(isGitDeliveryBlockReason)(value.blockReason));
+}
+function isExpectedBlockerArray(value) {
+    return Array.isArray(value) && value.every(isGitDeliveryExpectedBlocker);
+}
+function previewProviderFieldsValid(value) {
+    return (isUndefinedOr(isGitDeliveryPullRequestState)(value.pullRequest) &&
+        isUndefinedOr(isGitDeliveryMergeReadiness)(value.mergeReadiness) &&
+        isUndefinedOr(isGitDeliveryBranchProtection)(value.branchProtection) &&
+        isUndefinedOr(isGitDeliveryChecksState)(value.checks));
+}
+function previewScalarFieldsValid(value) {
+    return (value.schemaVersion === GIT_DELIVERY_ACTION_SHEET_SCHEMA_VERSION &&
+        isGitDeliveryActionKind(value.actionKind) &&
+        isGitDeliveryRiskClass(value.riskClass) &&
+        isNonNegativeInteger(value.riskSeverity) &&
+        isUndefinedOr(isNonEmptyString)(value.affectedBranchName) &&
+        isUndefinedOr(isNonEmptyString)(value.baseBranchName) &&
+        isUndefinedOr(isNonEmptyString)(value.remoteBranchName) &&
+        isUndefinedOr(isNonNegativeInteger)(value.estimatedFileCount) &&
+        isUndefinedOr(isNonNegativeInteger)(value.estimatedBytesDelta));
+}
+function previewFlagFieldsValid(value) {
+    return (isBoolean(value.touchesRemote) &&
+        isBoolean(value.wouldCreateRemoteBranch) &&
+        isBoolean(value.wouldForcePublish) &&
+        isBoolean(value.wouldTriggerChecks));
+}
+export function isGitDeliveryPreviewManifest(value) {
+    return (isRecord(value) &&
+        previewScalarFieldsValid(value) &&
+        previewFlagFieldsValid(value) &&
+        previewProviderFieldsValid(value) &&
+        isExpectedBlockerArray(value.expectedBlockers));
+}
+export function isGitDeliveryBlockedDetail(value) {
+    return (isRecord(value) &&
+        isGitDeliveryBlockedCause(value.cause) &&
+        isExpectedBlockerArray(value.expectedBlockers));
+}
+function actionSheetCoreFieldsValid(value) {
+    return (value.schemaVersion === GIT_DELIVERY_ACTION_SHEET_SCHEMA_VERSION &&
+        isNonEmptyString(value.actionId) &&
+        isGitDeliveryActionKind(value.actionKind) &&
+        isGitDeliveryActionSheetState(value.state));
+}
+function actionSheetCompositeFieldsValid(value) {
+    return (isGitDeliveryPreviewManifest(value.preview) &&
+        isGitDeliveryApprovalSummary(value.approval) &&
+        isGitDeliveryPolicyExplanation(value.policyExplanation) &&
+        Array.isArray(value.recovery) &&
+        value.recovery.every(isGitDeliveryRecoveryHint) &&
+        isUndefinedOr(isGitDeliveryBlockedDetail)(value.blocked));
+}
+function actionSheetBlockedInvariant(value) {
+    // blocked detail present iff state is blocked.
+    return (value.state === "blocked") === (value.blocked !== undefined);
+}
+export function isGitDeliveryActionSheet(value) {
+    return (isRecord(value) &&
+        actionSheetCoreFieldsValid(value) &&
+        actionSheetCompositeFieldsValid(value) &&
+        actionSheetBlockedInvariant(value));
+}
+export function parseGitDeliveryActionSheet(value) {
+    if (!isGitDeliveryActionSheet(value)) {
+        return { ok: false, errors: ["value is not a valid GitDeliveryActionSheet"] };
+    }
+    return { ok: true, value };
+}
+// ─── Pure projection helpers ─────────────────────────────────────────────────────────
+const REMOTE_ACTION_KINDS = [
+    "push",
+    "pr-create",
+    "pr-update",
+    "merge",
+];
+function actionTouchesRemote(kind) {
+    return REMOTE_ACTION_KINDS.includes(kind);
+}
+function affectedBranchOf(inputs) {
+    switch (inputs.kind) {
+        case "branch-create":
+        case "branch-switch":
+            return inputs.branchName;
+        case "push":
+            return inputs.sourceBranchName;
+        case "pr-create":
+        case "pr-update":
+            return inputs.headBranchName;
+        default:
+            return undefined;
+    }
+}
+function baseBranchOf(inputs) {
+    switch (inputs.kind) {
+        case "branch-create":
+        case "pr-create":
+        case "pr-update":
+            return inputs.baseBranchName;
+        default:
+            return undefined;
+    }
+}
+function remoteBranchOf(inputs) {
+    return inputs.kind === "push" ? inputs.remoteBranchName : undefined;
+}
+function wouldForcePublishOf(inputs) {
+    return inputs.kind === "push" && inputs.forcePush;
+}
+function wouldCreateRemoteBranchOf(inputs, kernelPreview) {
+    if (inputs.kind === "push") {
+        return inputs.setUpstreamTracking;
+    }
+    return kernelPreview?.wouldCreateRemoteBranch ?? false;
+}
+function previewBranchAndScopeFields(inputs, kernelPreview) {
+    const out = {};
+    const affected = affectedBranchOf(inputs);
+    if (affected !== undefined) {
+        out.affectedBranchName = affected;
+    }
+    const base = baseBranchOf(inputs);
+    if (base !== undefined) {
+        out.baseBranchName = base;
+    }
+    const remote = remoteBranchOf(inputs);
+    if (remote !== undefined) {
+        out.remoteBranchName = remote;
+    }
+    if (kernelPreview?.estimatedFileCount !== undefined) {
+        out.estimatedFileCount = kernelPreview.estimatedFileCount;
+    }
+    if (kernelPreview?.estimatedBytesDelta !== undefined) {
+        out.estimatedBytesDelta = kernelPreview.estimatedBytesDelta;
+    }
+    return out;
+}
+function previewProviderFields(input) {
+    const out = {};
+    if (input.pullRequest !== undefined) {
+        out.pullRequest = input.pullRequest;
+    }
+    if (input.mergeReadiness !== undefined) {
+        out.mergeReadiness = input.mergeReadiness;
+    }
+    if (input.branchProtection !== undefined) {
+        out.branchProtection = input.branchProtection;
+    }
+    if (input.checks !== undefined) {
+        out.checks = input.checks;
+    }
+    return out;
+}
+export function buildGitDeliveryPreviewManifest(input) {
+    const { resolvedInputs, kernelPreview } = input;
+    const riskClass = gitDeliveryRiskClassForInputs(resolvedInputs);
+    const touchesRemote = actionTouchesRemote(resolvedInputs.kind);
+    return {
+        schemaVersion: GIT_DELIVERY_ACTION_SHEET_SCHEMA_VERSION,
+        actionKind: resolvedInputs.kind,
+        riskClass,
+        riskSeverity: GIT_DELIVERY_RISK_CLASS_SEVERITY[riskClass],
+        ...previewBranchAndScopeFields(resolvedInputs, kernelPreview),
+        touchesRemote,
+        wouldCreateRemoteBranch: wouldCreateRemoteBranchOf(resolvedInputs, kernelPreview),
+        wouldForcePublish: wouldForcePublishOf(resolvedInputs),
+        // Re-derived from inputs (every remote action kind triggers checks), not read from
+        // kernelPreview.wouldTriggerChecks: the local kernel always reports false, and this projection
+        // owns the UI-facing derivation. The two are equivalent for the current action kinds.
+        wouldTriggerChecks: touchesRemote,
+        ...previewProviderFields(input),
+        expectedBlockers: input.expectedBlockers,
+    };
+}
+export function gitDeliveryApprovalNecessityForDecision(decision) {
+    switch (decision.outcome) {
+        case "approval-gated":
+            return "required";
+        case "blocked":
+            return decision.reason === "approval-expired" ? "required" : "impossible";
+        case "allowed":
+        case "constrained":
+            return "not-required";
+        default:
+            return "impossible";
+    }
+}
+function approvalIsAttached(approval) {
+    return approval.required;
+}
+function hasBlockingPreflight(blockers) {
+    return blockers.some((b) => b.source === "preflight" && b.severity === "blocking");
+}
+export function gitDeliveryActionSheetStateFor(input) {
+    if (!input.providerReady) {
+        return "blocked";
+    }
+    if (input.hasBlockingPreflight) {
+        return "blocked";
+    }
+    const decision = input.policyDecision;
+    if (decision.outcome === "blocked") {
+        return decision.reason === "approval-expired" ? "waiting-for-approval" : "blocked";
+    }
+    if (decision.outcome === "approval-gated") {
+        return approvalIsAttached(input.approvalRequirement)
+            ? "ready-to-execute"
+            : "waiting-for-approval";
+    }
+    return "ready-to-execute";
+}
+export function gitDeliveryBlockedCauseFor(input) {
+    if (!input.providerReady) {
+        return "provider-not-ready";
+    }
+    if (input.hasBlockingPreflight) {
+        return "preflight";
+    }
+    if (input.policyDecision.outcome === "blocked" &&
+        input.policyDecision.reason !== "approval-expired") {
+        return "policy";
+    }
+    return undefined;
+}
+// Fills the kernel's failure→suggested-strategy gap with a deterministic default: a dirty worktree
+// must be preserved (stash), a commit is undone non-destructively (soft reset), everything else
+// resets the index but keeps working-tree files (mixed reset).
+export function gitDeliverySuggestedRecoveryStrategy(actionKind, worktreeIsDirty) {
+    if (worktreeIsDirty) {
+        return "stash-and-reset";
+    }
+    if (actionKind === "commit") {
+        return "soft-reset";
+    }
+    return "mixed-reset";
+}
+function buildApprovalSummary(resolvedInputs, decision, approval) {
+    const riskClass = gitDeliveryRiskClassForInputs(resolvedInputs);
+    const necessity = gitDeliveryApprovalNecessityForDecision(decision);
+    const requiredApprovers = decision.outcome === "approval-gated" ? decision.requiredApprovers : [];
+    return {
+        necessity,
+        satisfied: necessity === "required" && approvalIsAttached(approval),
+        riskClass,
+        riskSeverity: GIT_DELIVERY_RISK_CLASS_SEVERITY[riskClass],
+        requiredApprovers,
+    };
+}
+function buildPolicyExplanation(decision) {
+    const requiredApprovers = decision.outcome === "approval-gated" ? decision.requiredApprovers : [];
+    const constraints = decision.outcome === "constrained" ? decision.constraints : [];
+    const base = {
+        decision: decision.outcome,
+        requiredApprovers,
+        constraints,
+    };
+    if (decision.outcome === "blocked") {
+        return { ...base, blockReason: decision.reason };
+    }
+    return base;
+}
+export function buildGitDeliveryActionSheet(input) {
+    const stateInput = {
+        policyDecision: input.policyDecision,
+        approvalRequirement: input.approvalRequirement,
+        providerReady: input.providerReady,
+        hasBlockingPreflight: hasBlockingPreflight(input.expectedBlockers),
+    };
+    const state = gitDeliveryActionSheetStateFor(stateInput);
+    const preview = buildGitDeliveryPreviewManifest({
+        resolvedInputs: input.resolvedInputs,
+        expectedBlockers: input.expectedBlockers,
+        kernelPreview: input.kernelPreview,
+        pullRequest: input.pullRequest,
+        mergeReadiness: input.mergeReadiness,
+        branchProtection: input.branchProtection,
+        checks: input.checks,
+    });
+    const base = {
+        schemaVersion: GIT_DELIVERY_ACTION_SHEET_SCHEMA_VERSION,
+        actionId: input.actionId,
+        actionKind: input.resolvedInputs.kind,
+        state,
+        preview,
+        approval: buildApprovalSummary(input.resolvedInputs, input.policyDecision, input.approvalRequirement),
+        policyExplanation: buildPolicyExplanation(input.policyDecision),
+        recovery: input.recovery,
+    };
+    if (state !== "blocked") {
+        return base;
+    }
+    const cause = gitDeliveryBlockedCauseFor(stateInput) ?? "policy";
+    return { ...base, blocked: { cause, expectedBlockers: input.expectedBlockers } };
+}

package/dist/git-delivery-evidence.d.ts

@@ -0,0 +1,92 @@
+import type { GitDeliveryActionKind, GitDeliveryBlockReason, GitDeliveryExecutionErrorCode, GitDeliveryExecutionOutcome, GitDeliveryEvidenceRef, GitDeliveryPolicyDecision, GitDeliveryRecoveryStrategyHint, GitDeliveryRiskClass } from "./git-delivery.js";
+import type { GitDeliveryRecoveryActionHint } from "./git-delivery-action-sheet.js";
+export declare const GIT_DELIVERY_EVIDENCE_SCHEMA_VERSION: "1";
+export type GitDeliveryEvidenceOutcomeClass = "succeeded" | "blocked" | "rejected" | "failed" | "recovery-required" | "approval-required";
+export declare const GIT_DELIVERY_EVIDENCE_OUTCOME_CLASSES: readonly GitDeliveryEvidenceOutcomeClass[];
+export type GitDeliveryRecoveryDisposition = "retryable" | "user-fixable" | "policy-forbidden" | "none";
+export declare const GIT_DELIVERY_RECOVERY_DISPOSITIONS: readonly GitDeliveryRecoveryDisposition[];
+export type GitDeliveryEvidenceLifecyclePhase = "resolve" | "preflight" | "preview" | "policy" | "execute" | "result";
+export declare const GIT_DELIVERY_EVIDENCE_LIFECYCLE_PHASES: readonly GitDeliveryEvidenceLifecyclePhase[];
+export interface GitDeliveryRecoveryMetadata {
+    readonly disposition: GitDeliveryRecoveryDisposition;
+    readonly actionHint?: GitDeliveryRecoveryActionHint | undefined;
+    readonly executionErrorCode?: GitDeliveryExecutionErrorCode | undefined;
+    readonly blockReason?: GitDeliveryBlockReason | undefined;
+    readonly suggestedRecoveryStrategy?: GitDeliveryRecoveryStrategyHint | undefined;
+}
+export interface GitDeliveryEvidenceCorrelation {
+    readonly workflowRunIdHash: string;
+    readonly actionId: string;
+    readonly attemptSequence?: number | undefined;
+}
+export interface GitDeliveryEvidenceApproval {
+    readonly required: boolean;
+    readonly approvalTokenHash?: string | undefined;
+    readonly approvedByUserId?: string | undefined;
+    readonly approvedAtMs?: number | undefined;
+    readonly expiresAtMs?: number | undefined;
+}
+export interface GitDeliveryEvidencePreviewSummary {
+    readonly affectedBranchName?: string | undefined;
+    readonly estimatedFileCount?: number | undefined;
+    readonly estimatedBytesDelta?: number | undefined;
+    readonly wouldCreateRemoteBranch: boolean;
+    readonly wouldTriggerChecks: boolean;
+}
+export interface GitDeliveryEvidenceExecution {
+    readonly outcome: GitDeliveryExecutionOutcome;
+    readonly durationMs: number;
+    readonly errorCode?: GitDeliveryExecutionErrorCode | undefined;
+    readonly attemptedUnitCount?: number | undefined;
+    readonly succeededUnitCount?: number | undefined;
+    readonly externalIdHash?: string | undefined;
+}
+export interface GitDeliveryEvidenceRepoContext {
+    readonly repoIdHash?: string | undefined;
+    readonly targetBranchName?: string | undefined;
+    readonly headDetached?: boolean | undefined;
+    readonly stagedFileCount?: number | undefined;
+    readonly unstagedFileCount?: number | undefined;
+    readonly untrackedFileCount?: number | undefined;
+    readonly remoteRefHash?: string | undefined;
+}
+export interface GitDeliveryEvidenceRecord {
+    readonly schemaVersion: typeof GIT_DELIVERY_EVIDENCE_SCHEMA_VERSION;
+    readonly evidenceId: string;
+    readonly actionKind: GitDeliveryActionKind;
+    readonly riskClass: GitDeliveryRiskClass;
+    readonly riskSeverity: number;
+    readonly outcomeClass: GitDeliveryEvidenceOutcomeClass;
+    readonly phaseReached: GitDeliveryEvidenceLifecyclePhase;
+    readonly policyOutcome: GitDeliveryPolicyDecision["outcome"];
+    readonly blockReason?: GitDeliveryBlockReason | undefined;
+    readonly requiredApprovers?: readonly string[] | undefined;
+    readonly correlation: GitDeliveryEvidenceCorrelation;
+    readonly approval: GitDeliveryEvidenceApproval;
+    readonly preview?: GitDeliveryEvidencePreviewSummary | undefined;
+    readonly execution?: GitDeliveryEvidenceExecution | undefined;
+    readonly repoContext: GitDeliveryEvidenceRepoContext;
+    readonly recovery: GitDeliveryRecoveryMetadata;
+    readonly recordedAtMs: number;
+    readonly evidenceRef?: GitDeliveryEvidenceRef | undefined;
+}
+export interface GitDeliveryAuditPacket {
+    readonly schemaVersion: typeof GIT_DELIVERY_EVIDENCE_SCHEMA_VERSION;
+    readonly generatedAtMs: number;
+    readonly recordCount: number;
+    readonly records: readonly GitDeliveryEvidenceRecord[];
+    readonly outcomeClassCounts: Readonly<Record<GitDeliveryEvidenceOutcomeClass, number>>;
+    readonly recoveryDispositionCounts: Readonly<Record<GitDeliveryRecoveryDisposition, number>>;
+    readonly knownLimitations: readonly string[];
+}
+export declare function gitDeliveryRecoveryDispositionForExecutionError(code: GitDeliveryExecutionErrorCode): GitDeliveryRecoveryDisposition;
+export declare function gitDeliveryRecoveryDispositionForBlockReason(reason: GitDeliveryBlockReason): GitDeliveryRecoveryDisposition;
+export declare const GIT_DELIVERY_AUDIT_PACKET_KNOWN_LIMITATIONS: readonly string[];
+export declare function buildGitDeliveryAuditPacket(records: readonly GitDeliveryEvidenceRecord[], generatedAtMs: number, extraLimitations?: readonly string[]): GitDeliveryAuditPacket;
+export declare const isGitDeliveryEvidenceOutcomeClass: (v: unknown) => v is GitDeliveryEvidenceOutcomeClass;
+export declare const isGitDeliveryRecoveryDisposition: (v: unknown) => v is GitDeliveryRecoveryDisposition;
+export declare const isGitDeliveryEvidenceLifecyclePhase: (v: unknown) => v is GitDeliveryEvidenceLifecyclePhase;
+export declare function isGitDeliveryRecoveryMetadata(value: unknown): value is GitDeliveryRecoveryMetadata;
+export declare function isGitDeliveryEvidenceRecord(value: unknown): value is GitDeliveryEvidenceRecord;
+export declare function isGitDeliveryAuditPacket(value: unknown): value is GitDeliveryAuditPacket;
+//# sourceMappingURL=git-delivery-evidence.d.ts.map

package/dist/git-delivery-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-delivery-evidence.d.ts","sourceRoot":"","sources":["../src/git-delivery-evidence.ts"],"names":[],"mappings":"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"}