@packall/core 0.0.1 → 0.1.0

package/src/{Archive.ts → archive.ts}

@@ -1,92 +1,92 @@
-/**
- * Turning a staged directory tree into a gzipped tarball.
- *
- * Uses `node-tar`, the same library npm itself packs with. Writing a USTAR
- * encoder by hand would be a fun afternoon and a bad idea: scoped package
- * paths routinely exceed the 100-byte name field, so correctness depends on
- * prefix-splitting and PAX headers that `tar` already gets right.
- */
-import * as Effect from "effect/Effect"
-import * as FileSystem from "effect/FileSystem"
-import type { PlatformError } from "effect/PlatformError"
-import { create } from "tar"
-import { ArchiveError } from "./Errors.js"
-import * as Progress from "./Progress.js"
-
-/** A finished archive. */
-export interface ArchiveResult {
-  readonly path: string
-  readonly bytes: number
-}
-
-/**
- * Packs `entries` (paths relative to `cwd`) into a gzipped tar at `outPath`.
- *
- * `portable` normalises uid/gid/mtime so the same inputs produce byte-identical
- * output — which matters when a security team wants to diff two bundles or
- * re-derive one from a manifest.
- */
-export const createArchive = (options: {
-  readonly cwd: string
-  readonly entries: ReadonlyArray<string>
-  readonly outPath: string
-  readonly gzipLevel?: number | undefined
-}): Effect.Effect<ArchiveResult, ArchiveError | PlatformError, FileSystem.FileSystem | Progress.Progress> =>
-  Effect.gen(function*() {
-    const fs = yield* FileSystem.FileSystem
-
-    yield* Progress.emit({
-      _tag: "ArchiveStarted",
-      path: options.outPath,
-      entryCount: options.entries.length
-    })
-
-    yield* Effect.tryPromise({
-      try: () =>
-        create(
-          {
-            gzip: options.gzipLevel === undefined ? true : { level: options.gzipLevel },
-            file: options.outPath,
-            cwd: options.cwd,
-            portable: true,
-            // Undo the `./` added below, so recorded entry names stay exactly
-            // the registry paths the manifest lists.
-            onWriteEntry: (entry) => {
-              entry.path = entry.path.replace(/^\.\//, "")
-            }
-          },
-          // Sorted so archive order is stable across runs and platforms.
-          [...options.entries].sort().map(dotSlash)
-        ),
-      catch: (cause) => new ArchiveError(options.outPath, describe(cause), { cause })
-    })
-
-    const info = yield* fs.stat(options.outPath)
-    const bytes = Number(info.size)
-
-    yield* Progress.emit({ _tag: "ArchiveCompleted", path: options.outPath, bytes })
-
-    return { path: options.outPath, bytes }
-  })
-
-/**
- * Guards every entry against tar's `@` convention.
- *
- * In a tar file list, a leading `@` means "splice in the entries of this other
- * archive" — a GNU convention `node-tar` implements by stripping the `@` and
- * looking for what is left. Every scoped package is a top-level entry starting
- * with `@`, so this hit the bundler in both possible ways:
- *
- * - `@oxc-project` became `oxc-project`, which does not exist, and the run died
- *   with an ENOENT naming a path that appears nowhere in the staging tree.
- * - `@esbuild` became `esbuild`, which *does* exist — the unscoped package of
- *   the same name sitting right next to it. No error, and every scoped tarball
- *   silently missing from a bundle that reported success. That is the dangerous
- *   one: you would not find out until the install failed behind the firewall.
- *
- * `./@scope` is not subject to the convention and resolves identically.
- */
-const dotSlash = (entry: string): string => (entry.startsWith("./") ? entry : `./${entry}`)
-
-const describe = (cause: unknown): string =>
-  cause instanceof Error ? cause.message : String(cause)
+/**
+ * Turning a staged directory tree into a gzipped tarball.
+ *
+ * Uses `node-tar`, the same library npm itself packs with. Writing a USTAR
+ * encoder by hand would be a fun afternoon and a bad idea: scoped package
+ * paths routinely exceed the 100-byte name field, so correctness depends on
+ * prefix-splitting and PAX headers that `tar` already gets right.
+ */
+import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import type { PlatformError } from "effect/PlatformError"
+import { create } from "tar"
+import { ArchiveError } from "./errors.js"
+import * as Progress from "./progress.js"
+
+/** A finished archive. */
+export type ArchiveResult = {
+  readonly path: string
+  readonly bytes: number
+}
+
+/**
+ * Packs `entries` (paths relative to `cwd`) into a gzipped tar at `outPath`.
+ *
+ * `portable` normalises uid/gid/mtime so the same inputs produce byte-identical
+ * output — which matters when a security team wants to diff two bundles or
+ * re-derive one from a manifest.
+ */
+export const createArchive = (options: {
+  readonly cwd: string
+  readonly entries: ReadonlyArray<string>
+  readonly outPath: string
+  readonly gzipLevel?: number | undefined
+}): Effect.Effect<ArchiveResult, ArchiveError | PlatformError, FileSystem.FileSystem | Progress.Progress> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+
+    yield* Progress.emit({
+      _tag: "ArchiveStarted",
+      path: options.outPath,
+      entryCount: options.entries.length
+    })
+
+    yield* Effect.tryPromise({
+      try: () =>
+        create(
+          {
+            gzip: options.gzipLevel === undefined ? true : { level: options.gzipLevel },
+            file: options.outPath,
+            cwd: options.cwd,
+            portable: true,
+            // Undo the `./` added below, so recorded entry names stay exactly
+            // the registry paths the manifest lists.
+            onWriteEntry: (entry) => {
+              entry.path = entry.path.replace(/^\.\//, "")
+            }
+          },
+          // Sorted so archive order is stable across runs and platforms.
+          options.entries.toSorted().map(dotSlash)
+        ),
+      catch: (cause) => new ArchiveError(options.outPath, describe(cause), { cause })
+    })
+
+    const info = yield* fs.stat(options.outPath)
+    const bytes = Number(info.size)
+
+    yield* Progress.emit({ _tag: "ArchiveCompleted", path: options.outPath, bytes })
+
+    return { path: options.outPath, bytes }
+  })
+
+/**
+ * Guards every entry against tar's `@` convention.
+ *
+ * In a tar file list, a leading `@` means "splice in the entries of this other
+ * archive" — a GNU convention `node-tar` implements by stripping the `@` and
+ * looking for what is left. Every scoped package is a top-level entry starting
+ * with `@`, so this hit the bundler in both possible ways:
+ *
+ * - `@oxc-project` became `oxc-project`, which does not exist, and the run died
+ *   with an ENOENT naming a path that appears nowhere in the staging tree.
+ * - `@esbuild` became `esbuild`, which *does* exist — the unscoped package of
+ *   the same name sitting right next to it. No error, and every scoped tarball
+ *   silently missing from a bundle that reported success. That is the dangerous
+ *   one: you would not find out until the install failed behind the firewall.
+ *
+ * `./@scope` is not subject to the convention and resolves identically.
+ */
+const dotSlash = (entry: string): string => (entry.startsWith("./") ? entry : `./${entry}`)
+
+const describe = (cause: unknown): string =>
+  cause instanceof Error ? cause.message : String(cause)