@riddledc/riddle-proof 0.1.0

package/dist/openclaw.d.cts

@@ -0,0 +1,40 @@
+import { IntegrationContext, JsonValue, RiddleProofRunParams } from './types.cjs';
+
+interface OpenClawProofedChangeParams {
+    repo?: string;
+    branch?: string;
+    change_request?: string;
+    commit_message?: string;
+    prod_url?: string;
+    capture_script?: string;
+    success_criteria?: string;
+    assertions_json?: string;
+    verification_mode?: string;
+    reference?: "prod" | "before" | "both";
+    base_branch?: string;
+    before_ref?: string;
+    allow_static_preview_fallback?: boolean;
+    context?: string;
+    reviewer?: string;
+    mode?: string;
+    build_command?: string;
+    build_output?: string;
+    server_image?: string;
+    server_command?: string;
+    server_port?: number;
+    server_path?: string;
+    use_auth?: boolean;
+    color_scheme?: "dark" | "light" | (string & {});
+    wait_for_selector?: string;
+    ship_after_verify?: boolean;
+    ship_mode?: "none" | "ship";
+    discord_channel?: string;
+    discord_thread_id?: string;
+    discord_message_id?: string;
+    discord_source_url?: string;
+}
+declare function parseOpenClawAssertions(value: unknown): JsonValue | undefined;
+declare function openClawIntegrationContext(params: OpenClawProofedChangeParams): IntegrationContext;
+declare function toRiddleProofRunParams(params: OpenClawProofedChangeParams): RiddleProofRunParams;
+
+export { type OpenClawProofedChangeParams, openClawIntegrationContext, parseOpenClawAssertions, toRiddleProofRunParams };

package/dist/openclaw.d.ts

@@ -0,0 +1,40 @@
+import { IntegrationContext, JsonValue, RiddleProofRunParams } from './types.js';
+
+interface OpenClawProofedChangeParams {
+    repo?: string;
+    branch?: string;
+    change_request?: string;
+    commit_message?: string;
+    prod_url?: string;
+    capture_script?: string;
+    success_criteria?: string;
+    assertions_json?: string;
+    verification_mode?: string;
+    reference?: "prod" | "before" | "both";
+    base_branch?: string;
+    before_ref?: string;
+    allow_static_preview_fallback?: boolean;
+    context?: string;
+    reviewer?: string;
+    mode?: string;
+    build_command?: string;
+    build_output?: string;
+    server_image?: string;
+    server_command?: string;
+    server_port?: number;
+    server_path?: string;
+    use_auth?: boolean;
+    color_scheme?: "dark" | "light" | (string & {});
+    wait_for_selector?: string;
+    ship_after_verify?: boolean;
+    ship_mode?: "none" | "ship";
+    discord_channel?: string;
+    discord_thread_id?: string;
+    discord_message_id?: string;
+    discord_source_url?: string;
+}
+declare function parseOpenClawAssertions(value: unknown): JsonValue | undefined;
+declare function openClawIntegrationContext(params: OpenClawProofedChangeParams): IntegrationContext;
+declare function toRiddleProofRunParams(params: OpenClawProofedChangeParams): RiddleProofRunParams;
+
+export { type OpenClawProofedChangeParams, openClawIntegrationContext, parseOpenClawAssertions, toRiddleProofRunParams };

package/dist/openclaw.js

@@ -0,0 +1,70 @@
+import {
+  normalizeIntegrationContext,
+  normalizeRunParams
+} from "./chunk-EPVZKWUS.js";
+import {
+  compactRecord
+} from "./chunk-2ZQNXVQC.js";
+
+// src/openclaw.ts
+function parseOpenClawAssertions(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return trimmed;
+  }
+}
+function openClawIntegrationContext(params) {
+  const hasDiscordContext = Boolean(params.discord_channel || params.discord_thread_id || params.discord_message_id || params.discord_source_url);
+  return normalizeIntegrationContext({
+    source: hasDiscordContext ? "discord" : "openclaw",
+    channel_id: params.discord_channel,
+    thread_id: params.discord_thread_id,
+    message_id: params.discord_message_id,
+    source_url: params.discord_source_url,
+    metadata: compactRecord({
+      wrapper: "openclaw",
+      tool: "proofed_change_run"
+    })
+  }, "openclaw");
+}
+function toRiddleProofRunParams(params) {
+  return normalizeRunParams({
+    repo: params.repo,
+    branch: params.branch,
+    change_request: params.change_request,
+    commit_message: params.commit_message,
+    prod_url: params.prod_url,
+    capture_script: params.capture_script,
+    success_criteria: params.success_criteria,
+    assertions: parseOpenClawAssertions(params.assertions_json),
+    verification_mode: params.verification_mode,
+    reference: params.reference,
+    base_branch: params.base_branch,
+    before_ref: params.before_ref,
+    allow_static_preview_fallback: params.allow_static_preview_fallback,
+    context: params.context,
+    reviewer: params.reviewer,
+    mode: params.mode,
+    build_command: params.build_command,
+    build_output: params.build_output,
+    server_image: params.server_image,
+    server_command: params.server_command,
+    server_port: params.server_port,
+    server_path: params.server_path,
+    use_auth: params.use_auth,
+    color_scheme: params.color_scheme,
+    wait_for_selector: params.wait_for_selector,
+    ship_mode: params.ship_mode || (params.ship_after_verify ? "ship" : void 0),
+    integration_context: openClawIntegrationContext(params)
+  });
+}
+export {
+  openClawIntegrationContext,
+  parseOpenClawAssertions,
+  toRiddleProofRunParams
+};

package/dist/result.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/result.ts
+var result_exports = {};
+__export(result_exports, {
+  applyTerminalMetadata: () => applyTerminalMetadata,
+  compactRecord: () => compactRecord,
+  createRunResult: () => createRunResult,
+  isSuccessfulStatus: () => isSuccessfulStatus,
+  isTerminalStatus: () => isTerminalStatus,
+  nonEmptyString: () => nonEmptyString,
+  normalizeTerminalMetadata: () => normalizeTerminalMetadata,
+  recordValue: () => recordValue
+});
+module.exports = __toCommonJS(result_exports);
+function isTerminalStatus(status) {
+  return status === "blocked" || status === "failed" || status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function isSuccessfulStatus(status) {
+  return status !== "blocked" && status !== "failed";
+}
+function compactRecord(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0 && value !== null && value !== ""));
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function normalizeTerminalMetadata(input) {
+  const riddleState = recordValue(input.riddleState) || {};
+  const result = recordValue(input.engineResult) || {};
+  const contract = recordValue(result.checkpointContract) || {};
+  const details = recordValue(input.checkpointDetails) || recordValue(contract.details) || {};
+  const markedReady = riddleState.marked_ready ?? result.marked_ready ?? result.markedReady ?? details.marked_ready ?? details.markedReady;
+  const finalized = riddleState.finalized ?? result.finalized ?? details.finalized;
+  return compactRecord({
+    pr_url: nonEmptyString(riddleState.pr_url) || nonEmptyString(result.pr_url) || nonEmptyString(result.prUrl) || nonEmptyString(details.pr_url) || nonEmptyString(details.prUrl),
+    marked_ready: typeof markedReady === "boolean" ? markedReady : void 0,
+    notification: recordValue(riddleState.notification) || recordValue(riddleState.discord_notification) || recordValue(result.notification) || recordValue(result.discord_notification),
+    proof_decision: nonEmptyString(riddleState.proof_decision) || nonEmptyString(result.proof_decision),
+    merge_recommendation: nonEmptyString(riddleState.merge_recommendation) || nonEmptyString(result.merge_recommendation),
+    finalized: typeof finalized === "boolean" ? finalized : void 0
+  });
+}
+function applyTerminalMetadata(state, metadata) {
+  const prUrl = nonEmptyString(metadata.pr_url);
+  if (prUrl) state.pr_url = prUrl;
+  if (typeof metadata.marked_ready === "boolean") state.marked_ready = metadata.marked_ready;
+  const notification = recordValue(metadata.notification);
+  if (notification) state.notification = notification;
+  const proofDecision = nonEmptyString(metadata.proof_decision);
+  if (proofDecision) state.proof_decision = proofDecision;
+  const mergeRecommendation = nonEmptyString(metadata.merge_recommendation);
+  if (mergeRecommendation) state.merge_recommendation = mergeRecommendation;
+  if (typeof metadata.finalized === "boolean") state.finalized = metadata.finalized;
+  return state;
+}
+function createRunResult(input) {
+  const status = input.status || input.state.status;
+  const ok = isSuccessfulStatus(status);
+  const state = input.metadata ? applyTerminalMetadata(input.state, input.metadata) : input.state;
+  state.status = status;
+  state.ok = ok;
+  return compactRecord({
+    ok,
+    status,
+    state_path: input.state_path ?? state.state_path ?? null,
+    iterations: state.iterations,
+    last_checkpoint: state.last_checkpoint ?? null,
+    last_summary: input.last_summary ?? null,
+    event_count: state.events.length,
+    pr_url: state.pr_url,
+    marked_ready: state.marked_ready,
+    notification: state.notification,
+    proof_decision: state.proof_decision,
+    merge_recommendation: state.merge_recommendation,
+    finalized: state.finalized,
+    blocker: state.blocker,
+    evidence_bundle: input.evidence_bundle,
+    raw: input.raw
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyTerminalMetadata,
+  compactRecord,
+  createRunResult,
+  isSuccessfulStatus,
+  isTerminalStatus,
+  nonEmptyString,
+  normalizeTerminalMetadata,
+  recordValue
+});

package/dist/result.d.cts

@@ -0,0 +1,25 @@
+import { RiddleProofRunState, RiddleProofTerminalMetadata, RiddleProofStatus, RiddleProofEvidenceBundle, RiddleProofRunResult } from './types.cjs';
+
+declare function isTerminalStatus(status: RiddleProofStatus): boolean;
+declare function isSuccessfulStatus(status: RiddleProofStatus): boolean;
+declare function compactRecord<T extends Record<string, unknown>>(input: T): Partial<T>;
+declare function nonEmptyString(value: unknown): string | undefined;
+declare function recordValue(value: unknown): Record<string, unknown> | undefined;
+interface TerminalMetadataInput {
+    riddleState?: Record<string, unknown> | null;
+    engineResult?: Record<string, unknown> | null;
+    checkpointDetails?: Record<string, unknown> | null;
+}
+declare function normalizeTerminalMetadata(input: TerminalMetadataInput): RiddleProofTerminalMetadata;
+declare function applyTerminalMetadata<T extends RiddleProofRunState>(state: T, metadata: RiddleProofTerminalMetadata): T;
+declare function createRunResult(input: {
+    state: RiddleProofRunState;
+    status?: RiddleProofStatus;
+    state_path?: string | null;
+    last_summary?: string | null;
+    metadata?: RiddleProofTerminalMetadata;
+    evidence_bundle?: RiddleProofEvidenceBundle;
+    raw?: Record<string, unknown>;
+}): RiddleProofRunResult;
+
+export { type TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunResult, isSuccessfulStatus, isTerminalStatus, nonEmptyString, normalizeTerminalMetadata, recordValue };

package/dist/result.d.ts

@@ -0,0 +1,25 @@
+import { RiddleProofRunState, RiddleProofTerminalMetadata, RiddleProofStatus, RiddleProofEvidenceBundle, RiddleProofRunResult } from './types.js';
+
+declare function isTerminalStatus(status: RiddleProofStatus): boolean;
+declare function isSuccessfulStatus(status: RiddleProofStatus): boolean;
+declare function compactRecord<T extends Record<string, unknown>>(input: T): Partial<T>;
+declare function nonEmptyString(value: unknown): string | undefined;
+declare function recordValue(value: unknown): Record<string, unknown> | undefined;
+interface TerminalMetadataInput {
+    riddleState?: Record<string, unknown> | null;
+    engineResult?: Record<string, unknown> | null;
+    checkpointDetails?: Record<string, unknown> | null;
+}
+declare function normalizeTerminalMetadata(input: TerminalMetadataInput): RiddleProofTerminalMetadata;
+declare function applyTerminalMetadata<T extends RiddleProofRunState>(state: T, metadata: RiddleProofTerminalMetadata): T;
+declare function createRunResult(input: {
+    state: RiddleProofRunState;
+    status?: RiddleProofStatus;
+    state_path?: string | null;
+    last_summary?: string | null;
+    metadata?: RiddleProofTerminalMetadata;
+    evidence_bundle?: RiddleProofEvidenceBundle;
+    raw?: Record<string, unknown>;
+}): RiddleProofRunResult;
+
+export { type TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunResult, isSuccessfulStatus, isTerminalStatus, nonEmptyString, normalizeTerminalMetadata, recordValue };

package/dist/result.js

@@ -0,0 +1,20 @@
+import {
+  applyTerminalMetadata,
+  compactRecord,
+  createRunResult,
+  isSuccessfulStatus,
+  isTerminalStatus,
+  nonEmptyString,
+  normalizeTerminalMetadata,
+  recordValue
+} from "./chunk-2ZQNXVQC.js";
+export {
+  applyTerminalMetadata,
+  compactRecord,
+  createRunResult,
+  isSuccessfulStatus,
+  isTerminalStatus,
+  nonEmptyString,
+  normalizeTerminalMetadata,
+  recordValue
+};

package/dist/state.cjs

@@ -0,0 +1,143 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/state.ts
+var state_exports = {};
+__export(state_exports, {
+  RIDDLE_PROOF_RUN_STATE_VERSION: () => RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent: () => appendRunEvent,
+  createRunState: () => createRunState,
+  normalizeIntegrationContext: () => normalizeIntegrationContext,
+  normalizeRunParams: () => normalizeRunParams,
+  setRunStatus: () => setRunStatus
+});
+module.exports = __toCommonJS(state_exports);
+
+// src/result.ts
+function compactRecord(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0 && value !== null && value !== ""));
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// src/state.ts
+var RIDDLE_PROOF_RUN_STATE_VERSION = "riddle-proof.run-state.v1";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeIntegrationContext(input, fallbackSource) {
+  const value = recordValue(input);
+  if (!value) {
+    return fallbackSource ? { source: fallbackSource } : void 0;
+  }
+  const metadata = recordValue(value.metadata);
+  return compactRecord({
+    source: nonEmptyString(value.source) || fallbackSource,
+    channel_id: nonEmptyString(value.channel_id),
+    thread_id: nonEmptyString(value.thread_id),
+    message_id: nonEmptyString(value.message_id),
+    source_url: nonEmptyString(value.source_url),
+    metadata: metadata && Object.keys(metadata).length ? metadata : void 0
+  });
+}
+function normalizeRunParams(input) {
+  return compactRecord({
+    repo: input.repo,
+    branch: input.branch,
+    change_request: input.change_request,
+    commit_message: input.commit_message,
+    prod_url: input.prod_url,
+    capture_script: input.capture_script,
+    success_criteria: input.success_criteria,
+    assertions: input.assertions,
+    verification_mode: input.verification_mode,
+    reference: input.reference,
+    base_branch: input.base_branch,
+    before_ref: input.before_ref,
+    allow_static_preview_fallback: input.allow_static_preview_fallback,
+    context: input.context,
+    reviewer: input.reviewer,
+    mode: input.mode,
+    build_command: input.build_command,
+    build_output: input.build_output,
+    server_image: input.server_image,
+    server_command: input.server_command,
+    server_port: input.server_port,
+    server_path: input.server_path,
+    use_auth: input.use_auth,
+    color_scheme: input.color_scheme,
+    wait_for_selector: input.wait_for_selector,
+    ship_mode: input.ship_mode,
+    integration_context: normalizeIntegrationContext(input.integration_context)
+  });
+}
+function createRunState(input) {
+  const createdAt = input.created_at || timestamp();
+  return compactRecord({
+    version: RIDDLE_PROOF_RUN_STATE_VERSION,
+    state_path: input.state_path,
+    status: input.status || "running",
+    created_at: createdAt,
+    updated_at: input.updated_at || createdAt,
+    request: normalizeRunParams(input.request),
+    iterations: input.iterations ?? 0,
+    last_checkpoint: input.last_checkpoint ?? null,
+    events: input.events ? [...input.events] : []
+  });
+}
+function appendRunEvent(state, input) {
+  const event = {
+    ts: input.ts || timestamp(),
+    kind: input.kind,
+    checkpoint: input.checkpoint,
+    stage: input.stage,
+    summary: input.summary,
+    details: input.details
+  };
+  state.events.push(compactRecord({
+    ts: event.ts,
+    kind: event.kind,
+    checkpoint: event.checkpoint,
+    stage: event.stage,
+    summary: event.summary,
+    details: event.details
+  }));
+  if (input.checkpoint !== void 0) state.last_checkpoint = input.checkpoint;
+  state.updated_at = event.ts;
+  return state;
+}
+function setRunStatus(state, status, at = timestamp()) {
+  state.status = status;
+  state.ok = status !== "blocked" && status !== "failed";
+  state.updated_at = at;
+  return state;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent,
+  createRunState,
+  normalizeIntegrationContext,
+  normalizeRunParams,
+  setRunStatus
+});

package/dist/state.d.cts

@@ -0,0 +1,23 @@
+import { RiddleProofRunParams, RiddleProofStatus, RiddleProofEvent, RiddleProofRunState, IntegrationContext } from './types.cjs';
+
+declare const RIDDLE_PROOF_RUN_STATE_VERSION: "riddle-proof.run-state.v1";
+interface CreateRunStateInput {
+    request: RiddleProofRunParams;
+    status?: RiddleProofStatus;
+    state_path?: string;
+    created_at?: string;
+    updated_at?: string;
+    iterations?: number;
+    last_checkpoint?: string | null;
+    events?: RiddleProofEvent[];
+}
+type RunEventInput = Omit<RiddleProofEvent, "ts"> & {
+    ts?: string;
+};
+declare function normalizeIntegrationContext(input?: Partial<IntegrationContext> | Record<string, unknown> | null, fallbackSource?: IntegrationContext["source"]): IntegrationContext | undefined;
+declare function normalizeRunParams(input: RiddleProofRunParams): RiddleProofRunParams;
+declare function createRunState(input: CreateRunStateInput): RiddleProofRunState;
+declare function appendRunEvent<T extends RiddleProofRunState>(state: T, input: RunEventInput): T;
+declare function setRunStatus<T extends RiddleProofRunState>(state: T, status: RiddleProofStatus, at?: string): T;
+
+export { type CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, type RunEventInput, appendRunEvent, createRunState, normalizeIntegrationContext, normalizeRunParams, setRunStatus };

package/dist/state.d.ts

@@ -0,0 +1,23 @@
+import { RiddleProofRunParams, RiddleProofStatus, RiddleProofEvent, RiddleProofRunState, IntegrationContext } from './types.js';
+
+declare const RIDDLE_PROOF_RUN_STATE_VERSION: "riddle-proof.run-state.v1";
+interface CreateRunStateInput {
+    request: RiddleProofRunParams;
+    status?: RiddleProofStatus;
+    state_path?: string;
+    created_at?: string;
+    updated_at?: string;
+    iterations?: number;
+    last_checkpoint?: string | null;
+    events?: RiddleProofEvent[];
+}
+type RunEventInput = Omit<RiddleProofEvent, "ts"> & {
+    ts?: string;
+};
+declare function normalizeIntegrationContext(input?: Partial<IntegrationContext> | Record<string, unknown> | null, fallbackSource?: IntegrationContext["source"]): IntegrationContext | undefined;
+declare function normalizeRunParams(input: RiddleProofRunParams): RiddleProofRunParams;
+declare function createRunState(input: CreateRunStateInput): RiddleProofRunState;
+declare function appendRunEvent<T extends RiddleProofRunState>(state: T, input: RunEventInput): T;
+declare function setRunStatus<T extends RiddleProofRunState>(state: T, status: RiddleProofStatus, at?: string): T;
+
+export { type CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, type RunEventInput, appendRunEvent, createRunState, normalizeIntegrationContext, normalizeRunParams, setRunStatus };

package/dist/state.js

@@ -0,0 +1,17 @@
+import {
+  RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent,
+  createRunState,
+  normalizeIntegrationContext,
+  normalizeRunParams,
+  setRunStatus
+} from "./chunk-EPVZKWUS.js";
+import "./chunk-2ZQNXVQC.js";
+export {
+  RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent,
+  createRunState,
+  normalizeIntegrationContext,
+  normalizeRunParams,
+  setRunStatus
+};

package/dist/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);