@ricsam/r5d-worker 0.0.81 → 0.0.83

package/dist/types/main.d.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import { Database } from "bun:sqlite";
+import type { WorkerGitIdentity } from "./git-identity";
 import { configureGitHubRegistryAuthFiles, type PreparedPrivateAuthFileGeneration } from "./registry-auth";
 type WorkerProjectConfig = {
     projectId: string;
@@ -22,6 +23,53 @@ type WorkerProjectConfig = {
         baseCommitHash: string;
     }>;
 };
+type WorkspaceSyncTrigger = {
+    type: "connect" | "inbound_head" | "write" | "edit" | "shell_inline" | "process_terminal" | "process_cancel" | "periodic" | "manual" | "remediation" | "remediation_confirm" | "remediation_reset";
+    sessionId?: string;
+    processRunId?: string;
+    toolCallId?: string;
+    projectId?: string;
+    branchName?: string;
+    detail?: string;
+};
+type WorkspaceSyncResult = {
+    type: "workspace_sync";
+    attemptId: string;
+    workerLabel: string;
+    trigger: WorkspaceSyncTrigger;
+    outcome: "no_change" | "published" | "updated" | "conflict_reset" | "large_diff_blocked" | "conflict_blocked" | "reset" | "failed";
+    startingHead: string | null;
+    localHead?: string;
+    publishedHead?: string;
+    rebaseCount: number;
+    diffSizeBytes: number;
+    gitStatus: string;
+    affectedProjects: string[];
+    affectedPaths: string[];
+    activeMountIds?: string[];
+    skippedMountIds?: string[];
+    activeProjectBranchPublications?: Array<{
+        branchId: string;
+        projectId: string;
+        branchName: string;
+    }>;
+    discardedPaths: string[];
+    localChangesDiscarded: boolean;
+    conflictPaths?: string[];
+    conflictSnapshotRefs?: {
+        local: string;
+        remote: string;
+    };
+    conflictKind?: "integration_rebase" | "projection_merge";
+    verifiedAncestorHeads?: string[];
+    telemetry?: {
+        totalMs: number;
+        queueMs: number;
+        prepareMs: number;
+        synchronizeMs: number;
+    };
+    error?: string;
+};
 export type WorkerSessionTarget = {
     type: "project";
     projectId: string;
@@ -31,6 +79,207 @@ export type WorkerSessionTarget = {
     ownerUserId: string;
     rootProfile: "visible_projects" | "canonical_sync";
 };
+type WorkerServerMessage = {
+    type: "connected";
+    label: string;
+    workerId: string;
+} | {
+    type: "workspace_config";
+    requestId: string;
+    projects: WorkerProjectConfig[];
+    workspaceRemoteUrl: string;
+    gitIdentity: WorkerGitIdentity;
+    githubCredential: WorkerGitHubCredential | null;
+    deferWorkspaceSyncForIncidentId?: string;
+} | {
+    type: "sync_workspace";
+    requestId: string;
+    attemptId: string;
+    trigger: WorkspaceSyncTrigger;
+    confirmedLargeDiff?: boolean;
+    confirmationReason?: string;
+    resetToCanonical?: boolean;
+    requiredAncestorHeads?: string[];
+} | {
+    type: "create_project_branch";
+    requestId: string;
+    branchId: string;
+    projectId: string;
+    sourceBranch: string;
+    targetBranch: string;
+} | {
+    type: "delete_project_branch";
+    requestId: string;
+    branchId: string;
+    projectId: string;
+    branchName: string;
+} | {
+    type: "code_list";
+    requestId: string;
+    target: Extract<WorkerSessionTarget, {
+        type: "project";
+    }>;
+    path: string;
+} | {
+    type: "code_read";
+    requestId: string;
+    target: Extract<WorkerSessionTarget, {
+        type: "project";
+    }>;
+    path: string;
+} | {
+    type: "sync_session_artifacts";
+    requestId: string;
+    sessionId: string;
+} | {
+    type: "workspace_incident_updated";
+    incidentId: string | null;
+    status: "remediating" | "waiting_for_worker" | "resolved" | "confirmed" | "reset" | null;
+    originWorkerLabel?: string;
+} | {
+    type: "exec_terminal_ack";
+    runId: string;
+} | {
+    type: "port_forward_connect";
+    forwardId: string;
+    relayConnectionId: string;
+    workerPort: number;
+} | {
+    type: "update_clis";
+    requestId: string;
+    workerPackageSpec: string;
+    r5dctlPackageSpec: string;
+    targetWorkerVersion: string;
+    targetR5dctlVersion: string;
+} | {
+    type: "exec";
+    requestId: string;
+    runId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    argv: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    workspaceEffect?: "none";
+} | {
+    type: "exec_start";
+    requestId: string;
+    runId: string;
+    target: WorkerSessionTarget;
+    sessionId: string;
+    argv: string[];
+    command: string;
+    mode: "foreground" | "detached";
+    credentialId?: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    interactive?: boolean;
+    workspaceEffect?: "none";
+} | {
+    type: "exec_stdin";
+    requestId: string;
+    runId: string;
+    data?: string;
+    eof?: boolean;
+} | {
+    type: "pty_open";
+    requestId: string;
+    ptyId: string;
+    target: WorkerSessionTarget;
+    cols: number;
+    rows: number;
+    command?: string;
+    env?: Record<string, string>;
+    envFiles?: Array<{
+        path: string;
+        content: string;
+        mode?: number;
+    }>;
+} | {
+    type: "pty_input";
+    ptyId: string;
+    data: string;
+} | {
+    type: "pty_resize";
+    ptyId: string;
+    cols: number;
+    rows: number;
+} | {
+    type: "pty_close";
+    ptyId: string;
+} | {
+    type: "read";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    activePlanId?: string;
+    filePath: string;
+    offset?: number;
+    limit?: number;
+} | {
+    type: "write";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    activePlanId?: string;
+    filePath: string;
+    content: string;
+} | {
+    type: "edit";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    activePlanId?: string;
+    filePath: string;
+    edits: Array<{
+        oldText: string;
+        newText: string;
+    }>;
+} | {
+    type: "grep";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    activePlanId?: string;
+    pattern: string;
+    path?: string;
+    glob?: string;
+    caseSensitive?: boolean;
+    limit?: number;
+} | {
+    type: "find";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    activePlanId?: string;
+    pattern?: string;
+    path?: string;
+    entryType?: string;
+    limit?: number;
+} | {
+    type: "ls";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    activePlanId?: string;
+    path?: string;
+    limit?: number;
+} | {
+    type: "view_file_bytes";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    activePlanId?: string;
+    filePath: string;
+} | {
+    type: "cancel";
+    requestId: string;
+    runId: string;
+} | {
+    type: "ping";
+};
 type WorkerReadFileResult = {
     type: "read";
     kind: "text";
@@ -114,6 +363,47 @@ declare function assertWorkerChildAdmission(input: {
     workspaceConfigured: boolean;
     runtimeHealthy: boolean;
 }): void;
+type WorkerPty = {
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    terminate(): Promise<void>;
+};
+type ActiveWorkerPty = WorkerPty & {
+    target: WorkerSessionTarget;
+    foregroundBusy: boolean;
+    lastInputAt: number;
+    releaseWorkspaceMutation?: () => void;
+};
+type StagedPtyEnvFiles = {
+    paths: string[];
+    resolvedByRequestedPath: Map<string, string>;
+};
+declare function resolvePtyEnvFilePath(requestedPath: string, temporaryRoot?: string): string;
+declare function removePtyEnvFiles(paths: readonly string[]): void;
+declare function stagePtyEnvFiles(envFiles: readonly {
+    path: string;
+    content: string;
+    mode?: number;
+}[] | undefined, temporaryRoot?: string): StagedPtyEnvFiles;
+declare function resolvePtyEnvFileReferences(env: Record<string, string>, staged: StagedPtyEnvFiles): Record<string, string>;
+declare function workerCommandHasWorkspaceEffect(message: {
+    workspaceEffect?: "none";
+}): boolean;
+declare function workerPtyIsWorkspaceBusy(pty: Pick<ActiveWorkerPty, "foregroundBusy" | "lastInputAt">, now?: number, foregroundIdleEnabled?: boolean): boolean;
+declare function parseLinuxPtyForegroundBusy(stat: string): boolean | null;
+export declare const workerPtyTestHarness: {
+    temporaryPathPrefix: string;
+    inputBusyGraceMs: number;
+    resolveEnvFilePath: typeof resolvePtyEnvFilePath;
+    stageEnvFiles: typeof stagePtyEnvFiles;
+    removeEnvFiles: typeof removePtyEnvFiles;
+    resolveEnvFileReferences: typeof resolvePtyEnvFileReferences;
+    commandHasWorkspaceEffect: typeof workerCommandHasWorkspaceEffect;
+    canonicalSyncTerminalHead: typeof canonicalSyncTerminalHead;
+    ptyIsWorkspaceBusy: typeof workerPtyIsWorkspaceBusy;
+    parseLinuxForegroundBusy: typeof parseLinuxPtyForegroundBusy;
+};
 export type WorkerBuiltInToolPaths = {
     artifactsDir?: string;
     plansDir?: string;
@@ -262,6 +552,51 @@ type CredentialReapContractProbe = {
 type CredentialReapContractStatus = "direct" | "systemd_unverified" | "verified_systemd";
 declare function credentialReapContractStatus(probe?: CredentialReapContractProbe): CredentialReapContractStatus;
 declare function verifiedCredentialReapContract(probe?: CredentialReapContractProbe): boolean;
+declare function workspaceConfigurationIncidentDeferral(input: {
+    requestedIncidentId: string | undefined;
+    activeIncidentId: string | null;
+}): {
+    incidentId: string | null;
+    error?: Error;
+};
+type DeferredWorkspaceConfiguration = {
+    incidentId: string;
+    serverRefreshExpected: boolean;
+};
+declare function workspaceIncidentTerminalClearDisposition(input: {
+    deferredConfiguration: DeferredWorkspaceConfiguration | null;
+    clearedIncidentId: string | null;
+}): "ordinary_resume" | "await_server_refresh" | "reconnect_for_refresh";
+declare function deferredWorkspaceTargetIsAllowed(deferredConfiguration: DeferredWorkspaceConfiguration | null, activeIncidentId: string | null, target: WorkerSessionTarget): boolean;
+declare function deferredWorkspaceSyncTriggerIsAllowed(deferredConfiguration: DeferredWorkspaceConfiguration | null, activeIncidentId: string | null, trigger: WorkspaceSyncTrigger): boolean;
+declare function workspaceOperationsAreFenced(deferredConfiguration: DeferredWorkspaceConfiguration | null, activeIncidentId: string | null): boolean;
+declare function workspaceCommandTransportIsAllowed(deferredConfiguration: DeferredWorkspaceConfiguration | null, activeIncidentId: string | null, transport: "exec" | "exec_start"): boolean;
+declare function deferredCredentialTransitionMustWait(input: {
+    incidentId: string | null;
+    transitionPhase: CredentialGenerationTransitionPhase;
+    canonicalRemediationActive: boolean;
+}): boolean;
+declare function workspaceConfigurationIncidentSnapshotIsCurrent(capturedIncidentId: string | null, activeIncidentId: string | null): boolean;
+declare function deferredWorkspaceRefreshWatchdogIsCurrent(input: {
+    capturedIncidentId: string;
+    deferredConfiguration: DeferredWorkspaceConfiguration | null;
+    activeIncidentId: string | null;
+}): boolean;
+declare function incidentDeferredProjectCheckouts(projects: readonly WorkerProjectConfig[]): Array<{
+    projectId: string;
+    branchName: string;
+}>;
+declare function deferredIncidentWorkspaceConfigurationResult(input: {
+    attemptId: string;
+    workerLabel: string;
+    head: string | null;
+    skippedMountIds: string[];
+}): WorkspaceSyncResult;
+declare function workspaceSyncFailureHydrationIsSafe(input: {
+    error: unknown;
+    resetToCanonical: boolean;
+    inspectCurrentHydration: () => boolean;
+}): boolean;
 declare function fenceUnsafeWorkspaceSyncFailure(input: {
     hydrationCurrent: boolean;
     invalidateExecution: () => void;
@@ -292,7 +627,21 @@ export declare const workerGitSecurityTestHarness: {
     credentialReapContractStatus: typeof credentialReapContractStatus;
     verifiedCredentialReapContract: typeof verifiedCredentialReapContract;
     fenceUnsafeWorkspaceSyncFailure: typeof fenceUnsafeWorkspaceSyncFailure;
+    workspaceConfigurationIncidentDeferral: typeof workspaceConfigurationIncidentDeferral;
+    workspaceIncidentTerminalClearDisposition: typeof workspaceIncidentTerminalClearDisposition;
+    deferredWorkspaceTargetIsAllowed: typeof deferredWorkspaceTargetIsAllowed;
+    deferredWorkspaceSyncTriggerIsAllowed: typeof deferredWorkspaceSyncTriggerIsAllowed;
+    workspaceOperationsAreFenced: typeof workspaceOperationsAreFenced;
+    workspaceCommandTransportIsAllowed: typeof workspaceCommandTransportIsAllowed;
+    deferredCredentialTransitionMustWait: typeof deferredCredentialTransitionMustWait;
+    workspaceConfigurationIncidentSnapshotIsCurrent: typeof workspaceConfigurationIncidentSnapshotIsCurrent;
+    deferredWorkspaceRefreshWatchdogIsCurrent: typeof deferredWorkspaceRefreshWatchdogIsCurrent;
+    incidentDeferredProjectCheckouts: typeof incidentDeferredProjectCheckouts;
+    deferredIncidentWorkspaceConfigurationResult: typeof deferredIncidentWorkspaceConfigurationResult;
+    workspaceSyncFailureHydrationIsSafe: typeof workspaceSyncFailureHydrationIsSafe;
     assertWorkerChildAdmission: typeof assertWorkerChildAdmission;
+    executeWriteFileOperation: typeof executeWriteFileOperation;
+    executeEditFileOperation: typeof executeEditFileOperation;
     terminateCredentialBearingChildren: typeof terminateCredentialBearingChildren;
     terminateCredentialBearingChildrenWithRetention: typeof terminateCredentialBearingChildrenWithRetention;
     commitCredentialGeneration(prepared: PreparedPrivateAuthFileGeneration, credential: WorkerGitHubCredential | null, children: readonly {
@@ -325,6 +674,7 @@ type ResolvedWorkerSessionTarget = {
     rootPath: string;
     config?: WorkerProjectConfig;
 };
+declare function canonicalSyncTerminalHead(resolvedTarget: Pick<ResolvedWorkerSessionTarget, "target" | "rootPath">, readHead?: (rootPath: string) => string): string | undefined;
 export declare function describeWorkerSessionTarget(target: WorkerSessionTarget): string;
 export declare function resolveWorkerSessionTarget(input: {
     target: WorkerSessionTarget;
@@ -349,6 +699,28 @@ export declare function editWorkerTextFile(branchPath: string, filePath: string,
     oldText: string;
     newText: string;
 }>, builtInPaths?: WorkerBuiltInToolPaths): WorkerEditFileResult;
+declare function executeWriteFileOperation(input: {
+    message: Extract<WorkerServerMessage, {
+        type: "write";
+    }>;
+    resolvedTarget: ResolvedWorkerSessionTarget;
+    baseUrl: string;
+    token: string;
+    artifactRoot: string;
+    planRoot: string;
+    assertAdmission: () => void;
+}): Promise<WorkerWriteFileResult>;
+declare function executeEditFileOperation(input: {
+    message: Extract<WorkerServerMessage, {
+        type: "edit";
+    }>;
+    resolvedTarget: ResolvedWorkerSessionTarget;
+    baseUrl: string;
+    token: string;
+    artifactRoot: string;
+    planRoot: string;
+    assertAdmission: () => void;
+}): Promise<WorkerEditFileResult>;
 export declare function grepWorkerFiles(branchPath: string, input: {
     pattern: string;
     path?: string;
@@ -375,6 +747,29 @@ export declare function prepareShellEnvForTarget(input: {
     artifactRoot: string;
     planRoot: string;
 }): Promise<Record<string, string>>;
+declare function createNodePtyBridge(options: {
+    file: string;
+    args: string[];
+    ptyOptions: {
+        name: string;
+        cols: number;
+        rows: number;
+        cwd: string;
+        env: Record<string, string | undefined>;
+    };
+    onOpened: (pid: number) => void;
+    onForeground: (busy: boolean) => void;
+    onOutput: (data: string) => void;
+    onExit: (event: {
+        exitCode: number;
+        signal?: number | string;
+    }) => void;
+    onError: (error: Error) => void;
+    onTerminationError: (error: Error) => void;
+}): WorkerPty;
+export declare const workerPtyBridgeTestHarness: {
+    create: typeof createNodePtyBridge;
+};
 export declare function resolveHostShell(command?: string, platform?: NodeJS.Platform): {
     file: string;
     args: string[];

package/dist/types/working-tree-mirror.d.ts

@@ -1,7 +1,7 @@
 export type WorkingTreeSourceMode = "all" | "git";
 export type WorkingTreeDeletionMode = "all" | "git";
 export type WorkingTreeMirrorDurability = "per_entry" | "deferred_private_staging";
-type TreeEntry = {
+export type TreeEntry = {
     kind: "directory";
     mode: number;
 } | {
@@ -35,4 +35,3 @@ export declare function mirrorWorkingTree(input: {
 }): {
     paths: string[];
 };
-export {};

package/dist/types/workspace-command-sync-policy.d.ts

@@ -12,9 +12,10 @@ type WorkspaceSyncCompletionBarrier = {
     afterCurrent(): Promise<void>;
 };
 /**
- * A visible command must not become active halfway through an outer sync. Wait
- * for the current cycle, then register the target without another await so a
- * later cycle observes the reservation and defers before integration.
+ * A project command may reserve immediately: per-mount hydration rechecks its
+ * busy predicate immediately before touching visible bytes. A visible-projects
+ * workspace command spans every project, so it keeps the whole-cycle barrier.
+ * Canonical remediation is serialized separately by the mutation gate.
  */
 export declare function reserveWorkspaceCommandAfterCurrentSync(target: WorkspaceCommandTarget, coordinator: WorkspaceSyncCompletionBarrier, reserve: () => void): Promise<void>;
 /**

package/dist/types/workspace-git-sync.d.ts

@@ -29,6 +29,8 @@ export type WorkspaceGitMount = {
     /** Remove the outer-workspace subtree when the mounted source was intentionally deleted. */
     deleteWhenSourceMissing?: boolean;
     busy?: () => boolean;
+    /** Monotonic/opaque visible-mutation token used to catch short writes that begin and end between busy checks. */
+    mutationToken?: () => string;
     /** Activity-only fence used before checkout readiness is established on reconnect. */
     busyForRecovery?: () => boolean;
 };
@@ -50,8 +52,14 @@ export type WorkspaceGitSyncResult = {
         local: string;
         remote: string;
     };
+    conflictKind?: "integration_rebase" | "projection_merge";
+    verifiedAncestorHeads?: string[];
     error?: string;
 };
+/** A guarded remediation was rejected before it was allowed to hydrate or publish. */
+export declare class WorkspaceRemediationAncestryError extends Error {
+    constructor(message: string);
+}
 declare function gitCommandArgs(args: string[]): string[];
 declare function workspaceCloneCommandArgs(args: string[], remoteUrl: string, credentialHelper?: string | null, credentialUsername?: string | null): string[];
 export declare function workspaceGitHydrationIsCurrent(workspacePath: string, mounts?: readonly WorkspaceGitMount[]): boolean;
@@ -65,6 +73,22 @@ declare function configureWorkspaceRepository(input: {
         email: string;
     };
 }): void;
+/**
+ * Rebind only the existing canonical checkout's local Git configuration while
+ * an incident owns its HEAD. In particular, this deliberately does not fetch,
+ * recover durability, move refs, reset the index/worktree, or inspect/abort an
+ * in-progress merge or rebase.
+ */
+export declare function configureExistingWorkspaceGitForRemediation(input: {
+    workspacePath: string;
+    remoteUrl: string;
+    credentialHelper?: string | null;
+    credentialUsername?: string | null;
+    gitIdentity: {
+        name: string;
+        email: string;
+    };
+}): void;
 export declare function ensureWorkspaceGitClone(input: {
     workspacePath: string;
     remoteUrl: string;
@@ -74,6 +98,7 @@ export declare function ensureWorkspaceGitClone(input: {
         name: string;
         email: string;
     };
+    preserveResolutionInProgress?: boolean;
 }): {
     localHead: string | null;
     remoteHead: string | null;
@@ -88,6 +113,8 @@ export declare function hydrateWorkspaceGitMounts(workspacePath: string, mounts:
 export declare function recoverWorkspaceGitHydration(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
     ignoreBusy?: boolean;
     deferMountIds?: ReadonlySet<string>;
+    preserveResolutionInProgress?: boolean;
+    preserveStaleBases?: boolean;
 }): void;
 export declare function resetWorkspaceGit(input: {
     workspacePath: string;
@@ -107,6 +134,7 @@ export declare function resetWorkspaceGit(input: {
     activeMountIds: string[];
     skippedMountIds: string[];
 };
+declare function diffSizeBytes(workspacePath: string, baseRevision: string | null, headRevision: string, limit: number): Promise<number>;
 export declare function synchronizeWorkspaceGit(input: {
     attemptId?: string;
     workerLabel: string;
@@ -125,6 +153,12 @@ export declare function synchronizeWorkspaceGit(input: {
     maxPushAttempts?: number;
     /** Publish edits already made in the outer clone without first projecting visible mounts over them. */
     skipMountMirror?: boolean;
+    /** Positive ancestry proof required before a remediation may integrate, publish, or hydrate. */
+    requiredAncestorHeads?: readonly string[];
+    /** Revalidate the worker/config/incident generation after every async boundary. */
+    assertStillAdmitted?: () => void;
+    /** Test seam for exercising an incident transition during asynchronous diff measurement. */
+    measureDiffSize?: typeof diffSizeBytes;
     afterWorkspacePublished?: (context: {
         publishedHead: string;
         activeMountIds: string[];

package/dist/types/workspace-merge-projection.d.ts

@@ -0,0 +1,42 @@
+import { type WorkingTreeSourceMode } from "./working-tree-mirror";
+export type WorkspaceMergeProjectionSupport = {
+    supported: true;
+} | {
+    supported: false;
+    error: string;
+};
+export type WorkspaceMergeProjectionMount = {
+    id: string;
+    sourcePath: string;
+    workspaceRelativePath: string;
+    sourceMode: WorkingTreeSourceMode;
+};
+export type WorkspaceMergeProjectionResult = {
+    kind: "clean";
+    resultTree: string;
+    oursCommit: string;
+} | {
+    kind: "conflict";
+    oursCommit: string;
+    conflictPaths: string[];
+    error: string;
+};
+declare function gitVersionIsSupported(version: string): boolean;
+export declare function workspaceMergeProjectionSupport(): WorkspaceMergeProjectionSupport;
+export declare function mergeWorkspaceProjectionMount(input: {
+    workspacePath: string;
+    mount: WorkspaceMergeProjectionMount;
+    basisHead: string;
+    currentHead: string;
+    attemptId: string;
+}): WorkspaceMergeProjectionResult;
+export declare function materializeWorkspaceProjectionTree(input: {
+    workspacePath: string;
+    workspaceRelativePath: string;
+    resultTree: string;
+}): void;
+export declare const workspaceMergeProjectionTestHarness: {
+    gitVersionIsSupported: typeof gitVersionIsSupported;
+    resetSupportProbe(): void;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.81",
+  "version": "0.0.83",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",