@fabricorg/platform 1.10.0 → 1.10.1

package/dist/index-sPUPs8pr.d.ts

@@ -0,0 +1,262 @@
+import { ActionId, ActorType, FabricRuntimeServices } from "./actions/index.js";
+//#region policies/reconciliation-required.d.ts
+/** A possibly committed domain effect requiring an operator decision at the handler transaction boundary. */
+declare class ReconciliationRequiredError extends Error {
+  readonly name = "ReconciliationRequiredError";
+  readonly code: "EXECUTION_RECONCILIATION_REQUIRED";
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Recognise a ReconciliationRequiredError, including one constructed by a second
+ * package copy (for example ESM and CommonJS builds loaded side by side).
+ */
+declare function isReconciliationRequiredError(error: unknown): error is ReconciliationRequiredError;
+//#endregion
+//#region policies/retryable-execution.d.ts
+/** A transient execution dependency failure; the host decides whether retry is safe. */
+declare class RetryableExecutionError extends Error {
+  readonly name = "RetryableExecutionError";
+  readonly code: "EXECUTION_RETRYABLE";
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Recognise a RetryableExecutionError, including one constructed by a second
+ * package copy (for example ESM and CommonJS builds loaded side by side).
+ */
+declare function isRetryableExecutionError(error: unknown): error is RetryableExecutionError;
+//#endregion
+//#region policies/index.d.ts
+type PolicyEvaluationResult = "pass" | "warn" | "block";
+type PolicyKind = "code" | "data" | "hybrid";
+type PolicyId = `${string}.v${number}`;
+type PolicyEvaluationMode = "preview" | "execute";
+declare function assertPolicyId(policyId: string): asserts policyId is PolicyId;
+interface PolicyContext<TDb = unknown> {
+  tenantId: string;
+  spaceId: string;
+  actionInvocationId: string;
+  actionId: string;
+  /** Authenticated actor identity supplied by the host. Omitted only by legacy hosts and previews. */
+  actorId?: string;
+  actorType?: ActorType;
+  parameters: unknown;
+  db: TDb;
+  now?: Date;
+  mode?: PolicyEvaluationMode;
+  /**
+   * Optional runtime services bag, mirroring {@link FabricRuntimeServices} on
+   * `ActionContext`. Lets the host inject dependencies (HTTP clients, secret
+   * managers, external policy engines such as OPA, feature flags, etc.) that
+   * a code policy evaluator may need without resorting to module-level
+   * globals. The shape is opaque to the platform — adapters narrow it.
+   */
+  services?: FabricRuntimeServices;
+  /** Explicit code-policy catalog for this runtime; absence fails closed. */
+  resolveCodePolicy?: (policyId: PolicyId) => PolicyEvaluator | undefined;
+}
+interface PolicyFact {
+  name: string;
+  value: unknown;
+  label?: string;
+}
+type PolicyCorrectiveActionKind = "invoke_action" | "navigate" | "manual";
+interface PolicyCorrectiveActionBase {
+  kind: PolicyCorrectiveActionKind;
+  label: string;
+  description?: string;
+  requiresRole?: string[];
+  requiresConfirmation?: boolean;
+}
+interface PolicyInvokeActionCorrectiveAction extends PolicyCorrectiveActionBase {
+  kind: "invoke_action";
+  actionId: ActionId;
+  parameters?: Record<string, unknown>;
+}
+interface PolicyNavigateCorrectiveAction extends PolicyCorrectiveActionBase {
+  kind: "navigate";
+  route?: string;
+  target?: {
+    surface?: string;
+    tab?: string;
+    field?: string;
+  };
+}
+interface PolicyManualCorrectiveAction extends PolicyCorrectiveActionBase {
+  kind: "manual";
+}
+type PolicyCorrectiveAction = PolicyInvokeActionCorrectiveAction | PolicyNavigateCorrectiveAction | PolicyManualCorrectiveAction;
+interface PolicyGuidance {
+  summary?: string;
+  factsUsed: PolicyFact[];
+  correctiveActions: PolicyCorrectiveAction[];
+}
+interface PolicyGuidanceValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+declare function validatePolicyGuidance(guidance: unknown): PolicyGuidanceValidationResult;
+interface PolicyOutcome {
+  policyId: PolicyId;
+  policyVersion: number;
+  policyKind?: PolicyKind;
+  result: PolicyEvaluationResult;
+  reason?: string;
+  guidance?: PolicyGuidance;
+  metadata?: Record<string, unknown>;
+  dispatchEvidence?: PolicyDispatchEvidence;
+}
+interface PolicyEvaluator<TDb = unknown> {
+  policyId: PolicyId;
+  version: number;
+  kind?: Extract<PolicyKind, "code">;
+  previewSafe?: boolean;
+  evaluate: (ctx: PolicyContext<TDb>) => Promise<PolicyOutcome>;
+}
+type DataPolicySource = "parameters" | "context";
+type DataPolicyLiteral = string | number | boolean | null;
+type DataPolicyComparisonOperator = "exists" | "equals" | "notEquals" | "gt" | "gte" | "lt" | "lte";
+interface DataPolicySourceReference {
+  source: DataPolicySource;
+  path: string;
+}
+type DataPolicyCondition = {
+  conditionId: string;
+  type: "always";
+  result: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "parameter";
+  path: string;
+  operator: DataPolicyComparisonOperator;
+  value?: DataPolicyLiteral;
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "comparison";
+  left: DataPolicySourceReference;
+  operator: DataPolicyComparisonOperator;
+  value?: DataPolicyLiteral;
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "all" | "any";
+  conditions: DataPolicyCondition[];
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+} | {
+  conditionId: string;
+  type: "not";
+  condition: DataPolicyCondition;
+  onPass?: PolicyEvaluationResult;
+  onFail?: PolicyEvaluationResult;
+  reason?: string;
+};
+interface DataPolicyDefinition {
+  conditions: DataPolicyCondition[];
+  defaultResult?: PolicyEvaluationResult;
+  reason?: string;
+}
+interface DataPolicyValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+interface PolicyFallbackDefinition {
+  codeEvaluatorPolicyId: PolicyId;
+  onResults?: PolicyEvaluationResult[];
+  triggers?: PolicyFallbackTrigger[];
+  reason?: string;
+}
+type PolicyFallbackTrigger = "data_result" | "missing_data_definition" | "invalid_data_definition";
+interface DataPolicyConditionResult {
+  conditionId: string;
+  passed: boolean;
+  result: PolicyEvaluationResult;
+  reason?: string;
+}
+/**
+ * Opaque, consumer-defined reference to the immutable policy authority or
+ * snapshot a runtime policy definition was resolved from. Platform records it
+ * in dispatch evidence and does not interpret it.
+ */
+interface PolicyAuthorityReference {
+  snapshotId: string;
+  contentHash?: string;
+}
+interface RuntimePolicyDefinition {
+  policyId: PolicyId;
+  policyVersion: number;
+  kind: PolicyKind;
+  /** Snapshot/authority this definition came from; copied into dispatch evidence. */
+  authority?: PolicyAuthorityReference;
+  dataDefinition?: DataPolicyDefinition;
+  codeEvaluatorPolicyId?: PolicyId;
+  fallback?: PolicyFallbackDefinition;
+}
+interface PolicyDispatchEvidence {
+  policyKind: PolicyKind;
+  policyId?: PolicyId;
+  policyVersion?: number;
+  /** Snapshot/authority the evaluated definition was resolved from, when supplied. */
+  authority?: PolicyAuthorityReference;
+  dispatchPath: Array<"data" | "code" | "fallback">;
+  data?: {
+    definitionVersion: number;
+    definitionStatus: "evaluated" | "missing" | "invalid";
+    conditionResults: DataPolicyConditionResult[];
+    validationErrors?: string[];
+  };
+  code?: {
+    requestedPolicyId?: PolicyId;
+    policyId: PolicyId;
+    version?: number;
+    registered: boolean;
+    skipped?: boolean;
+    skipReason?: string;
+  };
+  fallback?: {
+    used: boolean;
+    trigger: PolicyFallbackTrigger | "not_triggered";
+    reason: string;
+    fromResult?: PolicyEvaluationResult;
+    definitionVersion: number;
+    codeEvaluatorPolicyId: PolicyId;
+  };
+  /**
+   * Provenance for the engine that produced this decision when a code
+   * evaluator delegates to an external policy engine (OPA, Cedar, Cerbos,
+   * Topaz, etc.). Fabric's `policyId` / `policyVersion` remain canonical for
+   * audit; this block carries deployment provenance (decision path, bundle
+   * revision, decision ID, input hash). Adapters populate it; the platform
+   * keeps `metadata` open-ended so engine-specific typing can live in the
+   * adapter package.
+   */
+  engine?: {
+    name: string;
+    version?: string;
+    metadata?: Record<string, unknown>;
+  };
+}
+interface PolicyRegistry {
+  register(evaluator: PolicyEvaluator): void;
+  registerIfMissing(evaluator: PolicyEvaluator): void;
+  resolve(policyId: PolicyId): PolicyEvaluator | undefined;
+  ids(): PolicyId[];
+}
+declare function createPolicyRegistry(evaluators?: readonly PolicyEvaluator[]): PolicyRegistry;
+declare function evaluateRegisteredPolicies(policyIds: PolicyId[], ctx: PolicyContext): Promise<PolicyOutcome[]>;
+declare function evaluatePolicyDefinitions(policies: RuntimePolicyDefinition[], ctx: PolicyContext): Promise<PolicyOutcome[]>;
+declare function evaluatePolicyDefinition(policy: RuntimePolicyDefinition, ctx: PolicyContext): Promise<PolicyOutcome>;
+declare function validateDataPolicyDefinition(definition: DataPolicyDefinition): DataPolicyValidationResult;
+declare function aggregatePolicyOutcomes(outcomes: PolicyOutcome[]): PolicyOutcome | undefined;
+//#endregion
+export { RuntimePolicyDefinition as A, isRetryableExecutionError as B, PolicyId as C, PolicyNavigateCorrectiveAction as D, PolicyManualCorrectiveAction as E, evaluatePolicyDefinitions as F, isReconciliationRequiredError as H, evaluateRegisteredPolicies as I, validateDataPolicyDefinition as L, assertPolicyId as M, createPolicyRegistry as N, PolicyOutcome as O, evaluatePolicyDefinition as P, validatePolicyGuidance as R, PolicyGuidanceValidationResult as S, PolicyKind as T, ReconciliationRequiredError as V, PolicyEvaluator as _, DataPolicyLiteral as a, PolicyFallbackTrigger as b, DataPolicyValidationResult as c, PolicyCorrectiveAction as d, PolicyCorrectiveActionBase as f, PolicyEvaluationResult as g, PolicyEvaluationMode as h, DataPolicyDefinition as i, aggregatePolicyOutcomes as j, PolicyRegistry as k, PolicyAuthorityReference as l, PolicyDispatchEvidence as m, DataPolicyCondition as n, DataPolicySource as o, PolicyCorrectiveActionKind as p, DataPolicyConditionResult as r, DataPolicySourceReference as s, DataPolicyComparisonOperator as t, PolicyContext as u, PolicyFact as v, PolicyInvokeActionCorrectiveAction as w, PolicyGuidance as x, PolicyFallbackDefinition as y, RetryableExecutionError as z };

package/dist/index-z9-CYOIo.d.ts

@@ -0,0 +1,231 @@
+import { S as AnonymizationPolicy, o as AnonymizationMetadata } from "./index-BXpeFdk2.js";
+//#region evidence/canonical-json.d.ts
+/**
+ * Serializes a value as JSON with every object's keys sorted, recursively, by UTF-16 code-unit
+ * order (locale-independent). Array order is preserved.
+ *
+ * This is the serialization behind the `fabric-canonical-json-sha256-v1` digests: Host's
+ * parameter digests (`PARAMETER_DIGEST_ALGORITHM` in `@fabricorg/platform-host`) and evidence
+ * packet checksums (`EVIDENCE_PACKET_CHECKSUM_ALGORITHM`). Its output is a durable contract, so it
+ * must not change for any input. That includes values that are not plain JSON: any non-array
+ * object is rebuilt from its own enumerable entries before serialization, so a `Date` (which has
+ * none) serializes as `{}`, not as an ISO string. Convert dates to strings before calling this
+ * when they must survive into the output.
+ */
+declare function canonicalJson(value: unknown): string;
+//#endregion
+//#region evidence/generator.d.ts
+/**
+ * Identifies how `EvidencePacketEnvelope.checksum` is computed: the lowercase hex SHA-256 of
+ * `canonicalJson(payload)`. It is the same identifier as Host's `PARAMETER_DIGEST_ALGORITHM`
+ * because the algorithm is the same (SHA-256 over `canonicalJson`).
+ */
+declare const EVIDENCE_PACKET_CHECKSUM_ALGORITHM: "fabric-canonical-json-sha256-v1";
+/** Version of the `EvidencePacketPayload` shape produced by `generateEvidencePacket`. */
+declare const EVIDENCE_PACKET_SCHEMA_VERSION: 1;
+/** Packet type used when the input does not name one. */
+declare const DEFAULT_EVIDENCE_PACKET_TYPE = "compliance_evidence";
+/** Anonymization reason recorded when the caller does not supply one. */
+declare const DEFAULT_EVIDENCE_REDACTION_REASON = "evidence_packet_generation";
+/**
+ * A `Date`, or an ISO 8601 / PostgreSQL ISO date-time string with an explicit zone (`Z`, `+HH`,
+ * `+HH:MM` or `+HHMM`). Zone-less, non-ISO and out-of-range strings are rejected.
+ */
+type EvidenceTimestamp = Date | string;
+/** Tenant and space every record read through the port must belong to. */
+interface EvidenceScope {
+  tenantId: string;
+  spaceId: string;
+}
+/**
+ * An asset event as the read port returns it. `AssetEventEnvelope` (events) and `AssetEventLike`
+ * (privacy) both satisfy this shape. Fields beyond these are kept in the packet payload.
+ */
+interface EvidenceEventRecord {
+  id: string;
+  tenantId: string;
+  spaceId: string;
+  eventType: string;
+  subjectType: string;
+  subjectId: string;
+  actionInvocationId?: string | null;
+  sequence: number;
+  occurredAt: EvidenceTimestamp;
+  recordedAt: EvidenceTimestamp;
+  correlationId: string;
+  causationId?: string | null;
+  payload: unknown;
+}
+/** An action invocation, policy evaluation or adapter invocation record. Further fields are kept. */
+interface EvidenceRecord {
+  id: string;
+  tenantId: string;
+  spaceId: string;
+  actionInvocationId?: string | null;
+  [field: string]: unknown;
+}
+/** A record that belongs to one action invocation (policy evaluations, adapter invocations). */
+interface EvidenceInvocationRecord extends EvidenceRecord {
+  actionInvocationId: string;
+}
+interface EvidenceEventQuery extends EvidenceScope {
+  /** The subject the packet is about. Always `subjects[0]`. */
+  primarySubject: EvidencePacketSubject;
+  /** Primary subject first, then related subjects, de-duplicated and sorted. */
+  subjects: readonly EvidencePacketSubject[];
+}
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Read-only access to the application's evidence store. The generator filters nothing the port
+ * returns; it rejects, rather than drops, a record that fails one of its checks:
+ *
+ * - every record must have the generation context's `tenantId` and `spaceId`;
+ * - action invocations must have one of the requested ids, and policy evaluations and adapter
+ *   invocations one of the requested `actionInvocationId`s;
+ * - records must have the documented shape (non-empty `id`, event fields, parseable timestamps) and
+ *   be representable as plain JSON, and any `_privacy` value must be engine-written
+ *   `AnonymizationMetadata`.
+ *
+ * Which events belong to the packet is the port's decision: the generator does not check an event's
+ * subject against `subjects`, because a port may legitimately return events recorded against the
+ * primary subject's own action invocations under another subject.
+ */
+interface EvidencePacketReadPort {
+  /** Asset events for the given subjects within the tenant and space. Required. */
+  listEvents(query: EvidenceEventQuery): MaybePromise<readonly EvidenceEventRecord[]>;
+  /** The application's related-subject rules. When absent, only the primary subject is used. */
+  resolveRelatedSubjects?(subject: EvidencePacketSubject, scope: EvidenceScope): MaybePromise<readonly EvidencePacketSubject[]>;
+  /** Action invocations by id. When absent, the section is empty. */
+  listActionInvocations?(scope: EvidenceScope, ids: readonly string[]): MaybePromise<readonly EvidenceRecord[]>;
+  /** Policy evaluations for the given action invocations. When absent, the section is empty. */
+  listPolicyEvaluations?(scope: EvidenceScope, actionInvocationIds: readonly string[]): MaybePromise<readonly EvidenceInvocationRecord[]>;
+  /** Adapter invocations for the given action invocations. When absent, the section is empty. */
+  listAdapterInvocations?(scope: EvidenceScope, actionInvocationIds: readonly string[]): MaybePromise<readonly EvidenceInvocationRecord[]>;
+}
+/** A record after normalization: plain JSON, every `Date` replaced by its ISO string. */
+type EvidenceJsonRecord = Record<string, unknown>;
+interface EvidencePacketPayload {
+  schemaVersion: typeof EVIDENCE_PACKET_SCHEMA_VERSION;
+  packetType: string;
+  tenantId: string;
+  spaceId: string;
+  primarySubject: EvidencePacketSubject;
+  subjects: EvidencePacketSubject[];
+  includeRelated: boolean;
+  policyVersion?: string;
+  events: EvidenceJsonRecord[];
+  actionInvocations: EvidenceJsonRecord[];
+  policyEvaluations: EvidenceJsonRecord[];
+  adapterInvocations: EvidenceJsonRecord[];
+  /** Metadata from the anonymization pass over the rest of the payload (validated engine-written `_privacy` values pass through it unchanged). */
+  redaction: AnonymizationMetadata;
+}
+interface GenerateEvidencePacketInput {
+  subject: EvidencePacketSubject;
+  /** Set to `false` to skip `resolveRelatedSubjects`. Defaults to `true`. */
+  includeRelated?: boolean;
+  /** Defaults to `DEFAULT_EVIDENCE_PACKET_TYPE`. */
+  packetType?: string;
+  policyVersion?: string;
+}
+interface GenerateEvidencePacketOptions {
+  port: EvidencePacketReadPort;
+  /**
+   * Redaction applied to the whole payload with data class `"evidence_packet"`. Required so that
+   * redaction cannot be skipped by omission; pass `{ fields: [] }` to redact nothing.
+   */
+  anonymizationPolicy: AnonymizationPolicy;
+  anonymization?: {
+    /** Defaults to the packet id. */
+    jobId?: string;
+    /** Defaults to `DEFAULT_EVIDENCE_REDACTION_REASON`. */
+    reason?: string;
+    /** Defaults to the engine's `ANONYMIZATION_POLICY_VERSION`. */
+    policyVersion?: string;
+  };
+  /** Defaults to `createFabricId(FABRIC_ID_PREFIXES.complianceEvidencePacket)`. */
+  idFactory?: () => string;
+}
+type EvidencePacketGenerationErrorCode = "EVIDENCE_SCOPE_MISMATCH" | "EVIDENCE_INVALID_RECORD" | "EVIDENCE_UNREQUESTED_RECORD" | "EVIDENCE_IDENTIFIER_REDACTED";
+declare class EvidencePacketGenerationError extends Error {
+  readonly code: EvidencePacketGenerationErrorCode;
+  constructor(code: EvidencePacketGenerationErrorCode, message: string);
+}
+/** Lowercase hex SHA-256 of `canonicalJson(payload)`. */
+declare function computeEvidencePacketChecksum(payload: unknown): string;
+/**
+ * Builds a sealed evidence packet for one subject from the application's read port.
+ *
+ * Steps: resolve subjects (primary first, then related, de-duplicated and sorted); read events,
+ * then the action invocations, policy evaluations and adapter invocations those events reference;
+ * reject any record outside `context.tenantId`/`context.spaceId`; normalize to plain JSON and sort
+ * deterministically; redact the payload with `AnonymizationEngine` (data class
+ * `"evidence_packet"`); checksum the redacted payload; and build references from it.
+ *
+ * Nothing is persisted. Storing the returned envelope is the application's job.
+ */
+declare function generateEvidencePacket<TDb = unknown>(input: GenerateEvidencePacketInput, context: EvidenceGenerationContext<TDb>, options: GenerateEvidencePacketOptions): Promise<EvidencePacketEnvelope<EvidencePacketPayload>>;
+/**
+ * Recomputes an envelope's checksum. Returns `false`, never throws, when the checksum is missing,
+ * the algorithm is missing or unknown, the payload cannot be serialized, or the values differ.
+ * It covers `payload` only, which includes the subjects and the redaction metadata; the other
+ * envelope fields are not covered.
+ */
+declare function verifyEvidencePacketChecksum(envelope: Pick<EvidencePacketEnvelope<unknown>, "payload" | "checksum" | "checksumAlgorithm">): boolean;
+type EvidencePacketRendererInput = Omit<GenerateEvidencePacketInput, "packetType">;
+interface EvidencePacketRendererOptions extends GenerateEvidencePacketOptions {
+  packetType?: string;
+}
+/** Wraps `generateEvidencePacket` as an `EvidenceRenderer` for one packet type. */
+declare function createEvidencePacketRenderer<TDb = unknown>(options: EvidencePacketRendererOptions): EvidenceRenderer<EvidencePacketRendererInput, EvidencePacketPayload, TDb>;
+//#endregion
+//#region evidence/index.d.ts
+type EvidencePacketStatus = "draft" | "sealed" | "superseded";
+interface EvidencePacketSubject {
+  subjectType: string;
+  subjectId: string;
+}
+interface EvidencePacketReference {
+  referenceType: "action_invocation" | "asset_event" | "policy_evaluation" | "adapter_invocation" | "document" | "external_observation";
+  referenceId: string;
+  checksum?: string;
+  uri?: string;
+  metadata?: Record<string, unknown>;
+}
+interface EvidencePacketEnvelope<TPayload = Record<string, unknown>> {
+  id: string;
+  tenantId: string;
+  spaceId: string;
+  packetType: string;
+  status: EvidencePacketStatus;
+  subjects: EvidencePacketSubject[];
+  references: EvidencePacketReference[];
+  payload: TPayload;
+  generatedAt: Date | string;
+  generatedBy: string;
+  policyVersion?: string;
+  checksum?: string;
+  /**
+   * How `checksum` was computed. Packets built by `generateEvidencePacket` use
+   * `EVIDENCE_PACKET_CHECKSUM_ALGORITHM`. Optional and additive: envelopes built before this field
+   * existed omit it.
+   */
+  checksumAlgorithm?: string;
+  correlationId: string;
+  causationId?: string;
+}
+interface EvidenceGenerationContext<TDb = unknown> {
+  tenantId: string;
+  spaceId: string;
+  actorId: string;
+  correlationId: string;
+  causationId?: string;
+  db: TDb;
+  now?: Date;
+}
+interface EvidenceRenderer<TInput = unknown, TPayload = Record<string, unknown>, TDb = unknown> {
+  packetType: string;
+  render: (input: TInput, context: EvidenceGenerationContext<TDb>) => Promise<EvidencePacketEnvelope<TPayload>> | EvidencePacketEnvelope<TPayload>;
+}
+//#endregion
+export { canonicalJson as A, EvidenceTimestamp as C, createEvidencePacketRenderer as D, computeEvidencePacketChecksum as E, generateEvidencePacket as O, EvidenceScope as S, GenerateEvidencePacketOptions as T, EvidencePacketPayload as _, EvidencePacketSubject as a, EvidencePacketRendererOptions as b, DEFAULT_EVIDENCE_REDACTION_REASON as c, EvidenceEventQuery as d, EvidenceEventRecord as f, EvidencePacketGenerationErrorCode as g, EvidencePacketGenerationError as h, EvidencePacketStatus as i, verifyEvidencePacketChecksum as k, EVIDENCE_PACKET_CHECKSUM_ALGORITHM as l, EvidenceJsonRecord as m, EvidencePacketEnvelope as n, EvidenceRenderer as o, EvidenceInvocationRecord as p, EvidencePacketReference as r, DEFAULT_EVIDENCE_PACKET_TYPE as s, EvidenceGenerationContext as t, EVIDENCE_PACKET_SCHEMA_VERSION as u, EvidencePacketReadPort as v, GenerateEvidencePacketInput as w, EvidenceRecord as x, EvidencePacketRendererInput as y };