@interfere/vite 11.1.1 → 12.0.0

package/README.md

@@ -135,14 +135,14 @@ For **Vercel preview / production**, set `INTERFERE_API_KEY` in your `.env.local
 
 ## Environment Variables
 
-| Variable | Required | Description |
-| --- | --- | --- |
-| `VITE_INTERFERE_PUBLIC_KEY` | Yes | Surface public key in the `interfere_public_us_*` or `interfere_public_eu_*` format. Stamped into the page by the plugin at build time, and reused server-side (`register()`, request middleware) — the plugin mirrors it into the dev server's process, so no separate server variable is needed. |
-| `INTERFERE_API_KEY` | Yes for release metadata | Interfere secret key in the `interfere_secret_us_*` or `interfere_secret_eu_*` format. Used by the plugin at build time. Without it, release metadata is not published and the collector rejects events as `COLLECTOR_RELEASE_NOT_FOUND`. |
-| `INTERFERE_API_URL` | No | Override the collector URL the build pipeline targets. Defaults to `https://in.interfere.com`. |
-| `VITE_INTERFERE_API_URL` | No | Override the collector URL the browser kernel targets in direct mode. Proxy mode uses `INTERFERE_API_URL` server-side. |
-| `VITE_INTERFERE_COMMIT_SHA` | No | Override the auto-detected commit SHA used to derive the release slug. Defaults to `git rev-parse HEAD`. |
-| `VITE_INTERFERE_FORCE_ENABLE` | No | `"1"` / `"true"` flips the SDK into force-enable mode so `vite dev` (which sets `NODE_ENV=development`) emits events. Production collectors silently 202-drop force-enabled batches; safe to ship by mistake but useless. Use only in dev. |
+| Variable                      | Required                 | Description                                                                                                                                                                                                                                                                                        |
+| ----------------------------- | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `VITE_INTERFERE_PUBLIC_KEY`   | Yes                      | Surface public key in the `interfere_public_us_*` or `interfere_public_eu_*` format. Stamped into the page by the plugin at build time, and reused server-side (`register()`, request middleware) — the plugin mirrors it into the dev server's process, so no separate server variable is needed. |
+| `INTERFERE_API_KEY`           | Yes for release metadata | Interfere secret key in the `interfere_secret_us_*` or `interfere_secret_eu_*` format. Used by the plugin at build time. Without it, release metadata is not published and the collector rejects events as `COLLECTOR_RELEASE_NOT_FOUND`.                                                          |
+| `INTERFERE_API_URL`           | No                       | Override the collector URL the build pipeline targets. Defaults to `https://in.interfere.com`.                                                                                                                                                                                                     |
+| `VITE_INTERFERE_API_URL`      | No                       | Override the collector URL the browser kernel targets in direct mode. Proxy mode uses `INTERFERE_API_URL` server-side.                                                                                                                                                                             |
+| `VITE_INTERFERE_COMMIT_SHA`   | No                       | Override the auto-detected commit SHA used to derive the release slug. Defaults to `git rev-parse HEAD`.                                                                                                                                                                                           |
+| `VITE_INTERFERE_FORCE_ENABLE` | No                       | `"1"` / `"true"` flips the SDK into force-enable mode so `vite dev` (which sets `NODE_ENV=development`) emits events. Production collectors silently 202-drop force-enabled batches; safe to ship by mistake but useless. Use only in dev.                                                         |
 
 ## Plugin Options
 
@@ -152,11 +152,15 @@ interfere({
 });
 ```
 
-| Option | Default | Description |
-| --- | --- | --- |
-| `apiHost` | — | The endpoint the browser SDK posts to. Defaults to Interfere's endpoint. Set it to a subdomain of your own site (e.g. `"https://in.yourapp.com"`) that resolves to Interfere via a DNS record to survive ad-blockers, or to a regional endpoint. Add a CNAME pointing at the target shown in your dashboard; Interfere provisions TLS automatically. |
-| `commitSha` | `VITE_INTERFERE_COMMIT_SHA` → `git rev-parse HEAD` | Commit SHA used to derive the deterministic release slug. |
-| `sourceMaps` | auto | `false` disables build-time release metadata publishing. By default the pipeline runs when `INTERFERE_API_KEY` and a commit SHA are available. |
+| Option                        | Default                                            | Description                                                                                                                                                                                                                                                                                                                                                                              |
+| ----------------------------- | -------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `apiHost`                     | —                                                  | The endpoint the browser SDK posts to. Defaults to Interfere's endpoint. Set it to a subdomain of your own site (e.g. `"https://in.yourapp.com"`) that resolves to Interfere via a DNS record to survive ad-blockers, or to a regional endpoint. Add a CNAME pointing at the target shown in your dashboard; Interfere provisions TLS automatically.                                     |
+| `commitSha`                   | `VITE_INTERFERE_COMMIT_SHA` → `git rev-parse HEAD` | Commit SHA used to derive the deterministic release slug.                                                                                                                                                                                                                                                                                                                                |
+| `sourceMaps`                  | auto                                               | `false` disables build-time release metadata publishing. `"required"` fails the build if credentials, release identity, referenced source maps, or server acceptance are missing. By default the pipeline runs when `INTERFERE_API_KEY` and a commit SHA are available and reports publication failures as warnings.                                                                     |
+| `sourceMapReadinessTimeoutMs` | disabled                                           | Opt in to waiting for the same upload session, exact accepted batch, and published manifest. Requires `sourceMaps: "required"`; accepts 1 to 600000 milliseconds. Deploy the compatible status API before enabling. Transfer expiry remains separate.                                                                                                                                    |
+| `buildReceipt`                | disabled                                           | Private JSON path inside the project and outside public/build output directories. Records consumed SDK config and fetch status, original release/build identity, source publication status when available, and hashes of native Vite output files. Capture does not wait for readiness. Keep this artifact private; missing or fallback evidence cannot establish safe deployment reuse. |
+
+Build logs report release creation, signing, session lookup, upload, finalization, readiness waiting and cleanup in milliseconds, plus transferred bytes. Finalization confirms durable acceptance. Readiness waiting is disabled by default; when enabled, source maps remain local until the requested gate succeeds. The status API verifies the manifest in the upload's pinned storage bucket. It does not replace runtime stack/source canaries or continually rehash every previously published map.
 
 Ingest requests never carry cookies. `apiHost` posts to your own site's subdomain, surviving ad-blockers with no server-side component.
 
@@ -194,22 +198,22 @@ function useInterfereIdentity() {
 
 ### Parameters
 
-| Field | Required | Description |
-| --- | --- | --- |
-| `identifier` | Yes | Unique user ID (your internal ID, not email) |
-| `source` | Yes | Auth source: `{ type: "clerk", name: "Clerk" }`, `{ type: "auth0", name: "Auth0" }`, or `{ type: "custom", name: "Your Provider" }` |
-| `name` | No | Display name |
-| `email` | No | Email address |
-| `avatar` | No | Avatar URL |
-| `traits` | No | Arbitrary key-value metadata (`Record<string, unknown>`) |
+| Field        | Required | Description                                                                                                                         |
+| ------------ | -------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `identifier` | Yes      | Unique user ID (your internal ID, not email)                                                                                        |
+| `source`     | Yes      | Auth source: `{ type: "clerk", name: "Clerk" }`, `{ type: "auth0", name: "Auth0" }`, or `{ type: "custom", name: "Your Provider" }` |
+| `name`       | No       | Display name                                                                                                                        |
+| `email`      | No       | Email address                                                                                                                       |
+| `avatar`     | No       | Avatar URL                                                                                                                          |
+| `traits`     | No       | Arbitrary key-value metadata (`Record<string, unknown>`)                                                                            |
 
 ### API
 
-| Method | Description |
-| --- | --- |
+| Method                 | Description                                                                                         |
+| ---------------------- | --------------------------------------------------------------------------------------------------- |
 | `identity.set(params)` | Link the current session to a user. Deduplicated per session — only the first call sends a request. |
-| `identity.clear()` | Clears the linked identity and rotates the session. Call on logout. |
-| `identity.get()` | Returns the current `IdentifyParams`, or `null` if no identity has been set. |
+| `identity.clear()`     | Clears the linked identity and rotates the session. Call on logout.                                 |
+| `identity.get()`       | Returns the current `IdentifyParams`, or `null` if no identity has been set.                        |
 
 Identity is automatically cleared when the SDK is closed. Call `identity.clear()` on logout to start a fresh anonymous session.
 
@@ -231,13 +235,13 @@ function App() {
 
 ### Consent categories
 
-| Category | Plugins | Gated? |
-| --- | --- | --- |
-| `necessary` | Error tracking | Always on |
-| `analytics` | Page events, rage clicks, fingerprint | Yes |
-| `replay` | Session replay | Yes |
+| Category    | Plugins                               | Gated?    |
+| ----------- | ------------------------------------- | --------- |
+| `necessary` | Error tracking                        | Always on |
+| `analytics` | Page events, rage clicks, fingerprint | Yes       |
+| `replay`    | Session replay                        | Yes       |
 
-Omitting the `consent` prop disables gating entirely (all features load). Passing it enables gating — only `necessary` plugins plus explicitly consented categories will activate.
+Omitting the `consent` prop preserves consent supplied to `init()`, including later updates through `consent.set()`. If no initial consent was supplied, omitting the prop allows all features. Passing the prop enables only `necessary` plugins and explicitly consented categories.
 
 ### Imperative API
 
@@ -247,8 +251,8 @@ Use `consent.set()` and `consent.get()` from the `useInterfere` hook:
 const { consent } = useInterfere();
 
 consent.set({ analytics: true, replay: true }); // selective
-consent.set();                                   // grant all
-consent.get();                                   // current state, or null if no gating
+consent.set(); // grant all
+consent.get(); // current state, or null if no gating
 ```
 
 ### Initial consent via init

package/dist/init.d.mts

@@ -1,15 +1,15 @@
 import { capture, span } from "@interfere/react/api";
-import { Kernel, Kernel as Kernel$1, KernelOptions, KernelOptions as KernelOptions$1 } from "@interfere/react/internal/kernel";
+import { Kernel, KernelOptions, KernelOptions as KernelOptions$1 } from "@interfere/react/internal/kernel";
 import { ConsentCategory, ConsentState, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
 //#region src/init.d.ts
-declare function init(opts?: KernelOptions$1): Promise<Kernel$1 | null>;
-declare const close: () => Promise<void>, consent: {
+export declare function init(opts?: KernelOptions$1): Promise<import("@interfere/react/internal/kernel").Kernel | null>;
+export declare const close: () => Promise<void>, consent: {
   get: () => import("@interfere/types/sdk/plugins/manifest").ConsentState | null;
   set: (value?: import("@interfere/types/sdk/plugins/manifest").ConsentState) => void;
-}, getKernel: () => Kernel$1, getKernelOrNull: () => Kernel$1 | null, identity: {
+}, getKernel: () => import("@interfere/react/internal/kernel").Kernel, getKernelOrNull: () => import("@interfere/react/internal/kernel").Kernel | null, identity: {
   clear: () => void;
   get: () => import("@interfere/types/sdk/identify").IdentifyParams | null;
   set: (params: import("@interfere/types/sdk/identify").IdentifyParams) => Promise<void>;
 }, subscribeToKernel: (listener: () => void) => () => void;
 //#endregion
-export { type ConsentCategory, type ConsentState, type GateableCategory, type Kernel, type KernelOptions, capture, close, consent, getKernel, getKernelOrNull, identity, init, span, subscribeToKernel };
+export { type ConsentCategory, type ConsentState, type GateableCategory, type Kernel, type KernelOptions, capture, span };

package/dist/init.mjs

@@ -1 +1 @@
-import{applyBrowserGlobals}from"./internal/browser-globals.mjs";import{PRODUCER_VERSION}from"./version.mjs";import{createWrapperSingleton}from"@interfere/react/internal/wrapper-singleton";import{capture,span}from"@interfere/react/api";const wrapper=createWrapperSingleton({producerVersion:PRODUCER_VERSION,initEntryName:`Vite`});function init(opts){return applyBrowserGlobals(),wrapper.init(opts)}const{close,consent,getKernel,getKernelOrNull,identity,subscribeToKernel}=wrapper;export{capture,close,consent,getKernel,getKernelOrNull,identity,init,span,subscribeToKernel};
+import{applyBrowserGlobals}from"./internal/browser-globals.mjs";import{PRODUCER_VERSION}from"./version.mjs";import{createWrapperSingleton}from"@interfere/react/internal/wrapper-singleton";import{capture,span}from"@interfere/react/api";const wrapper=createWrapperSingleton({initEntryName:`Vite`,producerVersion:PRODUCER_VERSION});async function init(opts){return applyBrowserGlobals(),wrapper.init(opts)}const{close,consent,getKernel,getKernelOrNull,identity,subscribeToKernel}=wrapper;export{capture,close,consent,getKernel,getKernelOrNull,identity,init,span,subscribeToKernel};

package/dist/internal/browser-globals.d.mts

@@ -1,4 +1,3 @@
 //#region src/internal/browser-globals.d.ts
-declare function applyBrowserGlobals(): void;
-//#endregion
-export { applyBrowserGlobals };
+export declare function applyBrowserGlobals(): void;
+//#endregion

package/dist/internal/build/build-receipt.d.mts

@@ -0,0 +1,62 @@
+import { createBuildConfigResolver } from "@interfere/build/config";
+import { ReleaseSlug } from "@interfere/types/releases/slug";
+import { ResolvedConfig } from "vite";
+//#region src/internal/build/build-receipt.d.ts
+type ConfigObservation = Parameters<NonNullable<Parameters<typeof createBuildConfigResolver>[0]>>[0];
+export declare function createBuildReceipt(filename: string): {
+  observeConfig(this: void, observation: ConfigObservation): void;
+  configure(resolved: ResolvedConfig, build: NonNullable<{
+    commitSha: string | null;
+    releaseSlug: ReleaseSlug | null;
+    environment: string | null;
+    publicKey: string | undefined;
+    apiOrigin: string;
+    producerVersion: string;
+  } | null>): Promise<void>;
+  recordOutput(directory: string, files: string[]): Promise<void>;
+  recordPublication(source: NonNullable<{
+    releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+    buildId: string;
+    environment: string | null;
+    sessionId: string | null;
+    batchDigest: string;
+    status: {
+      releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+      environment: string | null;
+      sessionId: string | null;
+      state: "absent" | "accepted" | "expired" | "expiring" | "ready" | "uploading";
+      fileCount: number;
+      publishedFileCount: number;
+      batchDigest: string | null;
+      manifestReady: boolean;
+      diagnostics?: {
+        attempt: number;
+        scheduledAtMs: number | null;
+        startedAtMs: number;
+        completedAtMs: number | null;
+        phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+        publishedAtStart: number;
+        progressObservedAtMs: number | null;
+        nativeRetryCount: number;
+        interruptedAttempts: number;
+        longestAttempt: {
+          attempt: number;
+          durationMs: number;
+        } | null;
+        longestAlarmDelay: {
+          attempt: number;
+          durationMs: number;
+        } | null;
+        nextAlarmAtMs: number | null;
+        lastFailure: {
+          attempt: number;
+          atMs: number;
+          phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+          kind: "aborted" | "error" | "non-error" | "timeout";
+        } | null;
+      } | undefined;
+    } | null;
+  } | null>): void;
+  write(): Promise<void>;
+};
+//#endregion

package/dist/internal/build/build-receipt.mjs

@@ -0,0 +1 @@
+import{canonicalBuildPath}from"./canonical-build-path.mjs";import{hash}from"node:crypto";import path from"node:path";import{mkdir,readFile,rm,writeFile}from"node:fs/promises";function contains(directory,file){let relative=path.relative(directory,file);return relative===``||relative!==`..`&&!relative.startsWith(`..${path.sep}`)&&!path.isAbsolute(relative)}function createBuildReceipt(filename){let destination=null,root=``,config=null,identity=null,publication=null,outputs=new Set,directories=new Set;function assertPrivate(file){if([...directories].some(directory=>contains(directory,file)))throw Error(`Build receipt must be outside public and build output directories`)}return{observeConfig(observation){config=observation},async configure(resolved,build){root=await canonicalBuildPath(resolved.root),identity=build,directories.add(await canonicalBuildPath(path.resolve(root,resolved.build.outDir))),resolved.publicDir&&directories.add(await canonicalBuildPath(resolved.publicDir));let next=await canonicalBuildPath(path.resolve(root,filename));if(assertPrivate(next),!contains(root,next))throw Error(`Build receipt must be inside the project directory`);destination!==next&&await rm(next,{force:!0}),destination=next},async recordOutput(directory,files){let absolute=await canonicalBuildPath(path.resolve(root,directory));directories.add(absolute),destination&&assertPrivate(destination);for(let file of files)file.endsWith(`.map`)||outputs.add(path.resolve(absolute,file))},recordPublication(source){publication=source},async write(){if(!destination||!identity)return;assertPrivate(destination);let assets=await Promise.all([...outputs].toSorted().map(async file=>({path:path.relative(root,file).split(path.sep).join(`/`),sha256:hash(`sha256`,await readFile(file))}))),receipt={schemaVersion:1,build:{...identity,buildId:identity.commitSha},config:config?{status:config.status,consumed:config.config,digest:config.status===`fetched`?hash(`sha256`,JSON.stringify(config.config)):null}:{status:`unavailable`,consumed:null,digest:null},source:publication,assets};await mkdir(path.dirname(destination),{recursive:!0}),await writeFile(destination,`${JSON.stringify(receipt,null,2)}\n`,{mode:384})}}}export{createBuildReceipt};

package/dist/internal/build/canonical-build-path.d.mts

@@ -0,0 +1,3 @@
+//#region src/internal/build/canonical-build-path.d.ts
+export declare const canonicalBuildPath: (file: string) => Promise<string>;
+//#endregion

package/dist/internal/build/canonical-build-path.mjs

@@ -0,0 +1 @@
+import path from"node:path";import{realpath}from"node:fs/promises";const canonicalBuildPath=async file=>{let existing=await realpath(file).catch(()=>null);if(existing)return existing;let parent=path.dirname(file);return parent===file?file:path.join(await canonicalBuildPath(parent),path.basename(file))};export{canonicalBuildPath};

package/dist/internal/build/git.d.mts

@@ -0,0 +1,10 @@
+//#region src/internal/build/git.d.ts
+/**
+ * Runs a git command and returns its stdout, or `null` when git isn't
+ * available. Build-time only — inject it into the shared resolvers
+ * (`resolveReleaseSlug`, `resolveGithubReleaseSource`) rather than
+ * importing it from runtime server code, which must never spawn
+ * subprocesses.
+ */
+export declare function runGitCommand(command: string): string | null;
+//#endregion

package/dist/internal/build/git.mjs

@@ -0,0 +1 @@
+import{execSync}from"node:child_process";function runGitCommand(command){try{let output=execSync(command,{encoding:`utf8`,stdio:[`ignore`,`pipe`,`ignore`]}).trim();return output.length>0?output:null}catch{return null}}export{runGitCommand};

package/dist/internal/build/pipeline.d.mts

@@ -1,67 +1,93 @@
 import { DiscoveryResult } from "./source-maps.mjs";
+import { Interfere, InterfereClient } from "@interfere/javascript";
 import { ReleaseSlug } from "@interfere/types/releases/slug";
-import { HTTPClient, Interfere } from "@interfere/sdk";
 import { ManifestBundler } from "@interfere/types/data/source-maps";
-import { ReleasesConfigResponse } from "@interfere/sdk/models/releases-config-response.js";
-import { CreateReleaseResponse } from "@interfere/types/releases/definition";
 //#region src/internal/build/pipeline.d.ts
-interface BuildTiming {
-  cleanup: number;
-  createRelease: number;
-  fileCount: number;
-  preflight: number;
-  total: number;
-  totalBytes: number;
-  upload: number;
-}
-type ReleasePipelineFailure = {
-  kind: "missing_source_provider";
-  config: ReleasesConfigResponse;
-} | {
-  kind: "missing_destination_provider";
-  config: ReleasesConfigResponse;
-};
-type ReleasePipelineResult = {
-  ok: true;
-  data: ReleasePipelineSuccess;
-} | {
-  ok: false;
-  failure: ReleasePipelineFailure;
-};
-interface ReleasePipelineSuccess {
-  buildId: string;
-  cleanupFailures: {
-    absolute: string;
-    code: string | undefined;
-    message: string;
-  }[];
-  config: ReleasesConfigResponse;
-  fileCount: number;
-  release: CreateReleaseResponse;
-  releaseSlug: ReleaseSlug;
-  timing: BuildTiming;
-}
-interface ReleasePipelineInput {
-  apiKey: string;
-  apiUrl: string;
+export interface ReleasePipelineInput {
+  client: InterfereClient;
   buildId: string;
   bundler: ManifestBundler;
   discovery: DiscoveryResult;
   environment: string | null;
   producerVersion: string;
   releaseSlug: ReleaseSlug;
-  releasesConfig: ReleasesConfigResponse;
+  releasesConfig: Interfere.ReleasesConfigResponse;
+  readinessTimeoutMs?: number | undefined;
+  capturePublication?: boolean;
 }
-declare function createSdkClient(opts: {
-  apiKey: string;
-  apiUrl: string;
-}): {
-  httpClient: HTTPClient;
-  sdk: Interfere;
-  security: {
-    apiKey: string;
+export declare function runReleasePipeline(input: ReleasePipelineInput): Promise<{
+  failure: {
+    config: Interfere.ReleasesConfigResponse;
+    kind: "missing_destination_provider" | "missing_source_provider";
+  };
+  ok: false;
+  data?: never;
+} | {
+  failure?: never;
+  data: {
+    cleanupFailures: {
+      absolute: string;
+      code: string | undefined;
+      message: string;
+    }[];
+    fileCount: number;
+    releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+    publication: {
+      releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+      buildId: string;
+      environment: string | null;
+      sessionId: string | null;
+      batchDigest: string;
+      status: {
+        releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+        environment: string | null;
+        sessionId: string | null;
+        state: "absent" | "accepted" | "expired" | "expiring" | "ready" | "uploading";
+        fileCount: number;
+        publishedFileCount: number;
+        batchDigest: string | null;
+        manifestReady: boolean;
+        diagnostics?: {
+          attempt: number;
+          scheduledAtMs: number | null;
+          startedAtMs: number;
+          completedAtMs: number | null;
+          phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+          publishedAtStart: number;
+          progressObservedAtMs: number | null;
+          nativeRetryCount: number;
+          interruptedAttempts: number;
+          longestAttempt: {
+            attempt: number;
+            durationMs: number;
+          } | null;
+          longestAlarmDelay: {
+            attempt: number;
+            durationMs: number;
+          } | null;
+          nextAlarmAtMs: number | null;
+          lastFailure: {
+            attempt: number;
+            atMs: number;
+            phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+            kind: "aborted" | "error" | "non-error" | "timeout";
+          } | null;
+        } | undefined;
+      } | null;
+    } | undefined;
+    timing: {
+      sign: number;
+      session: number;
+      upload: number;
+      finalize: number;
+      totalBytes: number;
+      createRelease: number;
+      readiness: number;
+      receipt: number;
+      cleanup: number;
+      total: number;
+    };
   };
-};
-declare function runReleasePipeline(input: ReleasePipelineInput): Promise<ReleasePipelineResult>;
-//#endregion
-export { ReleasePipelineInput, ReleasePipelineResult, createSdkClient, runReleasePipeline };
+  ok: true;
+}>;
+//#endregion

package/dist/internal/build/pipeline.mjs

@@ -1 +1 @@
-import{cleanupSourceMaps,uploadSourceMaps}from"./source-maps.mjs";import{releaseSlugSchema}from"@interfere/types/releases/slug";import{applyDeployEnvironment}from"@interfere/types/sdk/deploy-environment";import{execSync}from"node:child_process";import{HTTPClient,Interfere}from"@interfere/sdk";import{configuredSourceProviderSchema,releaseDestinationProviderSchema}from"@interfere/types/integrations";import{resolveCliReleaseDestination}from"@interfere/types/sdk/cli-destination";import{parseEnvValue}from"@interfere/types/sdk/env";import{resolveGithubReleaseSource}from"@interfere/types/sdk/github-source";const sources={github:resolveGithubSource,ghe_cloud:resolveGithubSource,ghe_server:resolveGithubSource},destinations={vercel:resolveVercelDestination,cloudflare:resolveCloudflareDestination,cli:resolveCliDestination};async function timed(fn){let start=performance.now();return[await fn(),Math.round(performance.now()-start)]}function createSdkClient(opts){let httpClient=new HTTPClient;return httpClient.addHook(`beforeRequest`,request=>{let next=new Request(request);return next.headers.set(`Authorization`,`Bearer ${opts.apiKey}`),next}),{httpClient,sdk:new Interfere({serverURL:opts.apiUrl,httpClient}),security:{apiKey:opts.apiKey}}}function resolveReleaseRequest(buildId,environment,releaseSlug,producerVersion,config){let sourceProvider=configuredSourceProviderSchema.safeParse(config.surface.sourceProvider);if(!sourceProvider.success)return{ok:!1,reason:`missing_source_provider`};let destinationProvider=releaseDestinationProviderSchema.safeParse(config.surface.destinationProvider);return destinationProvider.success?{ok:!0,request:{source:sources[sourceProvider.data](),destination:applyDeployEnvironment(destinations[destinationProvider.data](releaseSlug),environment),buildId,slug:releaseSlug,producerVersion}}:{ok:!1,reason:`missing_destination_provider`}}async function runReleasePipeline(input){let{apiKey,apiUrl,bundler,discovery,releasesConfig}=input,releaseRequest=resolveReleaseRequest(input.buildId,input.environment,input.releaseSlug,input.producerVersion,releasesConfig);if(!releaseRequest.ok)return{ok:!1,failure:{kind:releaseRequest.reason,config:releasesConfig}};let start=performance.now(),{httpClient,sdk,security}=createSdkClient({apiKey,apiUrl}),[release,createReleaseMs]=await timed(()=>sdk.releases.create(security,releaseRequest.request)),releaseSlug=releaseSlugSchema.parse(release.destination.slug),buildId=release.build.hash??input.buildId,[{totalBytes},uploadMs]=await timed(()=>uploadSourceMaps({apiUrl,bundler,discovered:discovery,httpClient,releaseSlug})),[,preflightMs]=await timed(()=>sdk.releases.preflight(security,{releaseSlug})),[{failures},cleanupMs]=await timed(()=>cleanupSourceMaps(discovery.files));return{ok:!0,data:{buildId,cleanupFailures:failures,config:releasesConfig,fileCount:discovery.files.length,release:{...release,destination:{...release.destination,slug:releaseSlug}},releaseSlug,timing:{createRelease:createReleaseMs,upload:uploadMs,preflight:preflightMs,cleanup:cleanupMs,total:Math.round(performance.now()-start),fileCount:discovery.files.length,totalBytes}}}}function runGitCommand(command){try{let output=execSync(command,{encoding:`utf8`,stdio:[`ignore`,`pipe`,`ignore`]}).trim();return output.length>0?output:null}catch{return null}}function resolveGithubSource(){return resolveGithubReleaseSource(process.env,runGitCommand)}function resolveVercelDestination(){let environment=parseEnvValue(process.env.VERCEL_ENV??process.env.VERCEL_TARGET_ENV),deploymentId=parseEnvValue(process.env.VERCEL_DEPLOYMENT_ID);return{provider:`vercel`,destinationReleaseId:deploymentId,environment,deploymentId,deploymentUrl:resolveDeploymentUrl(),environmentName:environment,environmentTarget:environment}}function resolveDeploymentUrl(){let deploymentUrl=parseEnvValue(process.env.VERCEL_URL);return deploymentUrl===null?null:deploymentUrl.startsWith(`https://`)||deploymentUrl.startsWith(`http://`)?deploymentUrl:`https://${deploymentUrl}`}function resolveCloudflareDestination(){let raw=parseEnvValue(process.env.CF_VERSION_METADATA),versionMetadata=null;if(raw)try{versionMetadata=JSON.parse(raw)}catch{versionMetadata=null}let versionId=parseEnvValue(process.env.CF_VERSION_ID)??versionMetadata?.id??parseEnvValue(process.env.WORKERS_CI_BUILD_UUID)??null,scriptName=parseEnvValue(process.env.CF_WORKER_NAME)??parseEnvValue(process.env.WORKERS_CI_SCRIPT_NAME)??null,accountId=parseEnvValue(process.env.CF_ACCOUNT_ID)??parseEnvValue(process.env.CLOUDFLARE_ACCOUNT_ID)??null,environment=parseEnvValue(process.env.WORKERS_CI_BRANCH)??versionMetadata?.tag??null;return{provider:`cloudflare`,destinationReleaseId:versionId,environment,versionId,scriptName,accountId,deploymentUrl:resolveCloudflareDeploymentUrl(),environmentName:environment,environmentTarget:environment}}function resolveCloudflareDeploymentUrl(){let candidate=parseEnvValue(process.env.CF_PAGES_URL)??parseEnvValue(process.env.WORKERS_CI_DEPLOY_URL);return candidate===null?null:candidate.startsWith(`https://`)||candidate.startsWith(`http://`)?candidate:`https://${candidate}`}function resolveCliDestination(releaseSlug){return resolveCliReleaseDestination(process.env,releaseSlug)}export{createSdkClient,runReleasePipeline};
+import{readPublicationStatus}from"./read-publication-status.mjs";import{transferSourceMaps}from"./transfer-source-maps.mjs";import{waitForSourceMaps}from"./wait-for-source-maps.mjs";import{sourceMapBatchDigest}from"@interfere/types/data/source-map-batch";import{cleanupSourceMaps}from"@interfere/build/cleanup-source-maps";import{resolveReleaseRequest}from"@interfere/build/release-request";import{createReleaseResponse}from"@interfere/types/releases/definition";async function runReleasePipeline(input){let{client,discovery,releasesConfig}=input,{files}=discovery,releaseRequest=resolveReleaseRequest({...input,config:releasesConfig});if(!releaseRequest.ok)return{failure:{config:releasesConfig,kind:releaseRequest.reason},ok:!1};if(files.length===0)throw Error(`Source maps are required to prepare a release`);let start=performance.now(),release=createReleaseResponse.parse(await client.releases.createRelease(releaseRequest.request,{abortSignal:AbortSignal.timeout(6e4)})),createdAt=performance.now(),releaseSlug=release.destination.slug,transfer=await transferSourceMaps({...input,releaseSlug}),{completion,session,acceptedAt}=transfer;input.readinessTimeoutMs!==void 0&&session?.sessionId&&await waitForSourceMaps({client,releaseSlug,environment:input.environment,sessionId:session.sessionId,batchDigest:await sourceMapBatchDigest(completion),fileCount:files.length,timeoutMs:input.readinessTimeoutMs});let readyAt=performance.now(),publication=input.capturePublication?{releaseSlug,buildId:release.build.hash,environment:input.environment,sessionId:session?.releaseSlug===releaseSlug&&session.environment===input.environment?session.sessionId:null,batchDigest:await sourceMapBatchDigest(completion),status:await readPublicationStatus({...input,releaseSlug})}:void 0,publicationReadAt=performance.now();return{data:{cleanupFailures:await cleanupSourceMaps(files),fileCount:files.length,releaseSlug,publication,timing:{createRelease:Math.round(createdAt-start),...transfer.timing,readiness:Math.round(readyAt-acceptedAt),receipt:Math.round(publicationReadAt-readyAt),cleanup:Math.round(performance.now()-publicationReadAt),total:Math.round(performance.now()-start)}},ok:!0}}export{runReleasePipeline};

package/dist/internal/build/read-publication-status.d.mts

@@ -0,0 +1,39 @@
+import { ReleasePipelineInput } from "./pipeline.mjs";
+//#region src/internal/build/read-publication-status.d.ts
+export declare function readPublicationStatus(input: Pick<ReleasePipelineInput, "client" | "releaseSlug" | "environment">): Promise<{
+  releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+  environment: string | null;
+  sessionId: string | null;
+  state: "absent" | "accepted" | "expired" | "expiring" | "ready" | "uploading";
+  fileCount: number;
+  publishedFileCount: number;
+  batchDigest: string | null;
+  manifestReady: boolean;
+  diagnostics?: {
+    attempt: number;
+    scheduledAtMs: number | null;
+    startedAtMs: number;
+    completedAtMs: number | null;
+    phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+    publishedAtStart: number;
+    progressObservedAtMs: number | null;
+    nativeRetryCount: number;
+    interruptedAttempts: number;
+    longestAttempt: {
+      attempt: number;
+      durationMs: number;
+    } | null;
+    longestAlarmDelay: {
+      attempt: number;
+      durationMs: number;
+    } | null;
+    nextAlarmAtMs: number | null;
+    lastFailure: {
+      attempt: number;
+      atMs: number;
+      phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+      kind: "aborted" | "error" | "non-error" | "timeout";
+    } | null;
+  } | undefined;
+} | null>;
+//#endregion

package/dist/internal/build/read-publication-status.mjs

@@ -0,0 +1 @@
+import{sourceMapPublicationStatus}from"@interfere/types/data/source-map-status";async function readPublicationStatus(input){try{return sourceMapPublicationStatus.parse(await input.client.releases.getSourceMapPublicationStatus({releaseSlug:input.releaseSlug,environment:input.environment??void 0},{abortSignal:AbortSignal.timeout(1e4)}))}catch{return null}}export{readPublicationStatus};

package/dist/internal/build/render-debug-id.d.mts

@@ -0,0 +1,6 @@
+//#region src/internal/build/render-debug-id.d.ts
+export declare function renderDebugId(code: string): {
+  code: string;
+  map: null;
+};
+//#endregion

package/dist/internal/build/render-debug-id.mjs

@@ -0,0 +1 @@
+import{createHash}from"node:crypto";import{injectDebugIdIntoJs}from"@interfere/types/data/source-maps";function renderDebugId(code){let hash=createHash(`sha256`).update(code).digest(`hex`),debugId=[hash.slice(0,8),hash.slice(8,12),`8${hash.slice(13,16)}`,`8${hash.slice(17,20)}`,hash.slice(20,32)].join(`-`);return{code:injectDebugIdIntoJs(code,debugId),map:null}}export{renderDebugId};

package/dist/internal/build/source-maps.d.mts

@@ -1,16 +1,15 @@
-import { ReleaseSlug } from "@interfere/types/releases/slug";
-import { HTTPClient } from "@interfere/sdk";
-import { ManifestBundler, injectDebugIdIntoJs } from "@interfere/types/data/source-maps";
+import { injectDebugIdIntoJs } from "@interfere/types/data/source-maps";
 //#region src/internal/build/source-maps.d.ts
 interface SourceMapFile {
   readonly absolute: string;
   readonly chunkUrl: string;
+  readonly chunkAbsolutes: string[];
   readonly content: string;
   readonly debugId: string;
   readonly hash: string;
   readonly path: string;
 }
-interface DiscoveryResult {
+export interface DiscoveryResult {
   readonly files: SourceMapFile[];
   readonly sourceFileCount: number;
 }
@@ -18,32 +17,15 @@ interface PublicPathRewrite {
   from: string;
   to: string;
 }
-interface DiscoverByPairingOptions {
+export interface DiscoverByPairingOptions {
   distDir: string;
   projectDir: string;
   publicPathRewrites: readonly PublicPathRewrite[];
   subtrees: readonly string[];
 }
-interface CleanupFailure {
-  readonly absolute: string;
-  readonly code: string | undefined;
-  readonly message: string;
-}
-interface UploadParams {
-  apiUrl: string;
-  bundler: ManifestBundler;
-  discovered: DiscoveryResult;
-  httpClient: HTTPClient;
-  releaseSlug: ReleaseSlug;
-}
-interface UploadResult {
-  fileCount: number;
-  totalBytes: number;
-}
-declare function discoverByPairing(opts: DiscoverByPairingOptions): Promise<DiscoveryResult>;
-declare function cleanupSourceMaps(files: readonly SourceMapFile[]): Promise<{
-  failures: CleanupFailure[];
+export declare function discoverByPairing(opts: DiscoverByPairingOptions): Promise<{
+  files: SourceMapFile[];
+  sourceFileCount: number;
 }>;
-declare function uploadSourceMaps({ apiUrl, bundler, discovered, httpClient, releaseSlug }: UploadParams): Promise<UploadResult>;
 //#endregion
-export { CleanupFailure, DiscoverByPairingOptions, DiscoveryResult, SourceMapFile, UploadResult, cleanupSourceMaps, discoverByPairing, injectDebugIdIntoJs, uploadSourceMaps };
+export { injectDebugIdIntoJs };

package/dist/internal/build/source-maps.mjs

@@ -1 +1 @@
-import{isAbsolute,join,relative,resolve}from"node:path";import{createHash,randomUUID}from"node:crypto";import{readFile,readdir,unlink,writeFile}from"node:fs/promises";import{injectDebugIdIntoJs,injectDebugIdIntoJs as injectDebugIdIntoJs$1,readDebugIdFromJs}from"@interfere/types/data/source-maps";const LEADING_DOT_SLASH_RE=/^(\.\/)+/,SOURCEMAPPING_RE=/\/\/[#@]\s*sourceMappingURL=(\S+)\s*$/,SCRIPT_SUFFIXES=[`.js`,`.mjs`,`.cjs`];function normalizeDistDir(distDir){return distDir.replaceAll(`\\`,`/`).replace(LEADING_DOT_SLASH_RE,``)}function resolveDistDir(projectDir,distDir){return isAbsolute(distDir)?distDir:resolve(projectDir,distDir)}async function walkDistTrees(absDistDir,suffixes,subtrees){return(await Promise.all(subtrees.map(async subtree=>{let root=subtree===`.`?absDistDir:join(absDistDir,subtree),entries=await readdir(root,{recursive:!0}).catch(()=>[]),out=[];for(let entry of entries)typeof entry==`string`&&suffixes.some(suffix=>entry.endsWith(suffix))&&out.push(join(root,entry));return out}))).flat()}function toPublicPath(rel,rewrites){let normalized=rel.replaceAll(`\\`,`/`);for(let{from,to}of rewrites){let prefix=from.endsWith(`/`)?from:`${from}/`;if(normalized.startsWith(prefix))return`${to}${normalized.slice(prefix.length)}`}return normalized}function injectDebugIdIntoMap(content,debugId){let json=JSON.parse(content);return json.debugId=debugId,JSON.stringify(json)}async function discoverByPairing(opts){let absDistDir=resolveDistDir(opts.projectDir,normalizeDistDir(opts.distDir)),jsPaths=await walkDistTrees(absDistDir,SCRIPT_SUFFIXES,opts.subtrees),pairs=new Map;for(let jsAbs of jsPaths){let content=await readFile(jsAbs,`utf8`),match=SOURCEMAPPING_RE.exec(content);if(!match?.[1])continue;let mapAbs=`${jsAbs.slice(0,jsAbs.lastIndexOf(`/`)+1)}${decodeURIComponent(match[1])}`,jsPublic=toPublicPath(relative(absDistDir,jsAbs),opts.publicPathRewrites),mapPublic=toPublicPath(relative(absDistDir,mapAbs),opts.publicPathRewrites);pairs.set(mapPublic,{existingDebugId:readDebugIdFromJs(content),jsAbs,jsContent:content,jsPublic,mapAbs})}return{files:(await Promise.all(Array.from(pairs.entries(),async([mapPublic,pair])=>{let mapContent=await readFile(pair.mapAbs,`utf8`).catch(()=>null);if(mapContent===null)return null;let debugId=pair.existingDebugId??randomUUID();pair.existingDebugId||await writeFile(pair.jsAbs,injectDebugIdIntoJs$1(pair.jsContent,debugId),`utf8`);let finalMap=JSON.parse(mapContent).debugId===debugId?mapContent:injectDebugIdIntoMap(mapContent,debugId);return finalMap!==mapContent&&await writeFile(pair.mapAbs,finalMap,`utf8`),{absolute:pair.mapAbs,path:mapPublic,content:finalMap,hash:createHash(`sha256`).update(finalMap).digest(`hex`),debugId,chunkUrl:pair.jsPublic}}))).filter(file=>file!==null),sourceFileCount:pairs.size}}async function cleanupSourceMaps(files){let results=await Promise.allSettled(files.map(file=>unlink(file.absolute))),failures=[];for(let[index,result]of results.entries()){if(result.status!==`rejected`)continue;let error=result.reason;if(error.code===`ENOENT`)continue;let file=files[index];failures.push({absolute:file?.absolute??`<unknown>`,code:error.code,message:error.message??String(error)})}return{failures}}async function uploadSourceMaps({apiUrl,bundler,discovered,httpClient,releaseSlug}){let filesByPath=new Map(discovered.files.map(file=>[file.path,file])),signRequest={files:discovered.files.map(file=>({path:file.path,sizeBytes:byteLengthOf(file.content),...extractRichness(file.content)}))},signResponse=await postJson(httpClient,new URL(`/v1/releases/${encodeURIComponent(releaseSlug)}/source-maps/sign`,apiUrl),signRequest),totalBytes=0;await mapWithConcurrency(signResponse.uploads,32,async upload=>{let file=filesByPath.get(upload.path);if(!file)throw Error(`Sign response referenced unknown path "${upload.path}"`);totalBytes+=byteLengthOf(file.content),await putToR2(upload.presignedUrl,file.content)});let completeRequest={files:discovered.files.map(file=>({path:file.path,hash:file.hash,debugId:file.debugId,chunkUrl:file.chunkUrl})),sourceFileCount:discovered.sourceFileCount,bundler};return{fileCount:(await postJson(httpClient,new URL(`/v1/releases/${encodeURIComponent(releaseSlug)}/source-maps/complete`,apiUrl),completeRequest)).fileCount,totalBytes}}function byteLengthOf(content){return new TextEncoder().encode(content).byteLength}const EMPTY_RICHNESS={hasSourcesContent:!1,hasNames:!1,hasFile:!1,mappingsPresent:!1};function leafRichness(map){let sourcesContent=map.sourcesContent,names=map.names,file=map.file,mappings=map.mappings;return{hasSourcesContent:Array.isArray(sourcesContent)&&sourcesContent.length>0,hasNames:Array.isArray(names)&&names.length>0,hasFile:typeof file==`string`&&file.length>0,mappingsPresent:typeof mappings==`string`&&mappings.length>0}}function extractRichness(content){let parsed;try{parsed=JSON.parse(content)}catch{return EMPTY_RICHNESS}if(!(parsed&&typeof parsed==`object`))return EMPTY_RICHNESS;let top=parsed,sections=top.sections;if(!Array.isArray(sections))return leafRichness(top);let merged={hasSourcesContent:!1,hasNames:!1,hasFile:typeof top.file==`string`&&top.file.length>0,mappingsPresent:!1};for(let section of sections){let inner=section?.map;if(!(inner&&typeof inner==`object`))continue;let richness=leafRichness(inner);merged.hasSourcesContent||=richness.hasSourcesContent,merged.hasNames||=richness.hasNames,merged.mappingsPresent||=richness.mappingsPresent}return merged}async function postJson(httpClient,url,body){let response=await httpClient.request(new Request(url,{method:`POST`,headers:{"content-type":`application/json`,accept:`application/json`},body:JSON.stringify(body)}));if(!response.ok){let detail=await response.text().catch(()=>``);throw Error(`Source-map API request failed: POST ${url.pathname} -> ${response.status} ${detail}`)}return await response.json()}async function putToR2(presignedUrl,content){let response=await fetch(presignedUrl,{method:`PUT`,headers:{"content-type":`application/json`},body:content});if(!response.ok){let detail=await response.text().catch(()=>``);throw Error(`Release metadata file upload failed: ${response.status} ${detail}`)}}async function mapWithConcurrency(items,concurrency,fn){let cursor=0;async function worker(){for(;;){let index=cursor++;if(index>=items.length)return;let item=items[index];if(item===void 0)return;await fn(item,index)}}await Promise.all(Array.from({length:Math.min(concurrency,items.length)},()=>worker()))}export{cleanupSourceMaps,discoverByPairing,injectDebugIdIntoJs,uploadSourceMaps};
+import{createHash,randomUUID}from"node:crypto";import{isAbsolute,join,relative,resolve}from"node:path";import{readFile,readdir,writeFile}from"node:fs/promises";import{injectDebugIdIntoJs,injectDebugIdIntoJs as injectDebugIdIntoJs$1,readDebugIdFromJs}from"@interfere/types/data/source-maps";import{mapWithConcurrency}from"@interfere/helpers/map-with-concurrency";const LEADING_DOT_SLASH_RE=/^(?:\.\/)+/u,SOURCEMAPPING_RE=/\/\/[#@]\s*sourceMappingURL=(?<sourceMap>\S+)\s*$/u,RUNTIME_DEBUG_ID_RE=/_debugIds\[[^\]]+\]\s*=\s*["'`](?<id>[a-fA-F0-9-]{36})["'`]/gu,SCRIPT_SUFFIXES=[`.js`,`.mjs`,`.cjs`];function normalizeDistDir(distDir){return distDir.replaceAll(`\\`,`/`).replace(LEADING_DOT_SLASH_RE,``)}function resolveDistDir(projectDir,distDir){return isAbsolute(distDir)?distDir:resolve(projectDir,distDir)}async function walkDistTrees(absDistDir,suffixes,subtrees){return(await Promise.all(subtrees.map(async subtree=>{let root=subtree===`.`?absDistDir:join(absDistDir,subtree),entries=await readdir(root,{recursive:!0}).catch(()=>[]),out=[];for(let entry of entries)suffixes.some(suffix=>entry.endsWith(suffix))&&out.push(join(root,entry));return out}))).flat()}function toPublicPath(rel,rewrites){let normalized=rel.replaceAll(`\\`,`/`);for(let{from,to}of rewrites){let prefix=from.endsWith(`/`)?from:`${from}/`;if(normalized.startsWith(prefix))return`${to}${normalized.slice(prefix.length)}`}return normalized}function injectDebugIdIntoMap(content,debugId){let json=JSON.parse(content);if(typeof json!=`object`||!json||Array.isArray(json))throw TypeError(`Source map must be a JSON object`);return Reflect.set(json,`debugId`,debugId),JSON.stringify(json)}async function discoverByPairing(opts){let absDistDir=resolveDistDir(opts.projectDir,normalizeDistDir(opts.distDir)),jsPaths=await walkDistTrees(absDistDir,SCRIPT_SUFFIXES,opts.subtrees),discovered=await mapWithConcurrency(jsPaths,16,async jsAbs=>{let content=await readFile(jsAbs,`utf8`),match=SOURCEMAPPING_RE.exec(content);if(!match?.groups?.sourceMap)return null;let mapAbs=`${jsAbs.slice(0,jsAbs.lastIndexOf(`/`)+1)}${decodeURIComponent(match.groups.sourceMap)}`,jsPublic=toPublicPath(relative(absDistDir,jsAbs),opts.publicPathRewrites);return[toPublicPath(relative(absDistDir,mapAbs),opts.publicPathRewrites),{existingDebugId:readDebugIdFromJs(content)??[...content.matchAll(RUNTIME_DEBUG_ID_RE)].at(-1)?.groups?.id,jsAbs,jsContent:content,jsPublic,mapAbs}]}),pairs=new Map;for(let[mapPublic,pair]of discovered.filter(entry=>entry!==null)){let chunkAbsolutes=pairs.get(mapPublic)?.chunkAbsolutes??[];pairs.set(mapPublic,{...pair,chunkAbsolutes:[...chunkAbsolutes,pair.jsAbs]})}return{files:(await mapWithConcurrency([...pairs],16,async([mapPublic,pair])=>{let mapContent=await readFile(pair.mapAbs,`utf8`).catch(()=>null);if(mapContent===null)return null;let debugId=pair.existingDebugId??randomUUID(),mapJson=JSON.parse(mapContent),finalMap=typeof mapJson==`object`&&mapJson&&`debugId`in mapJson&&mapJson.debugId===debugId?mapContent:injectDebugIdIntoMap(mapContent,debugId);return pair.existingDebugId||await writeFile(pair.jsAbs,injectDebugIdIntoJs$1(pair.jsContent,debugId),`utf8`),finalMap!==mapContent&&await writeFile(pair.mapAbs,finalMap,`utf8`),{absolute:pair.mapAbs,chunkAbsolutes:pair.chunkAbsolutes,chunkUrl:pair.jsPublic,content:finalMap,debugId,hash:createHash(`sha256`).update(finalMap).digest(`hex`),path:mapPublic}})).filter(file=>file!==null),sourceFileCount:pairs.size}}export{discoverByPairing,injectDebugIdIntoJs};

package/dist/internal/build/transfer-source-maps.d.mts

@@ -0,0 +1,59 @@
+import { ReleasePipelineInput } from "./pipeline.mjs";
+//#region src/internal/build/transfer-source-maps.d.ts
+export declare function transferSourceMaps(input: Pick<ReleasePipelineInput, "client" | "bundler" | "discovery" | "environment" | "releaseSlug" | "readinessTimeoutMs" | "capturePublication">): Promise<{
+  completion: {
+    bundler: "rollup" | "tsc" | "turbopack" | "webpack";
+    sourceFileCount: number;
+    files: {
+      path: string;
+      hash: string;
+      debugId: string;
+      chunkUrl: string;
+    }[];
+  };
+  session: {
+    releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+    environment: string | null;
+    sessionId: string | null;
+    state: "absent" | "accepted" | "expired" | "expiring" | "ready" | "uploading";
+    fileCount: number;
+    publishedFileCount: number;
+    batchDigest: string | null;
+    manifestReady: boolean;
+    diagnostics?: {
+      attempt: number;
+      scheduledAtMs: number | null;
+      startedAtMs: number;
+      completedAtMs: number | null;
+      phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+      publishedAtStart: number;
+      progressObservedAtMs: number | null;
+      nativeRetryCount: number;
+      interruptedAttempts: number;
+      longestAttempt: {
+        attempt: number;
+        durationMs: number;
+      } | null;
+      longestAlarmDelay: {
+        attempt: number;
+        durationMs: number;
+      } | null;
+      nextAlarmAtMs: number | null;
+      lastFailure: {
+        attempt: number;
+        atMs: number;
+        phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+        kind: "aborted" | "error" | "non-error" | "timeout";
+      } | null;
+    } | undefined;
+  } | null;
+  acceptedAt: number;
+  timing: {
+    sign: number;
+    session: number;
+    upload: number;
+    finalize: number;
+    totalBytes: number;
+  };
+}>;
+//#endregion