scriptc 0.1.7 → 0.2.1

package/dist/usage.d.ts

@@ -1,78 +0,0 @@
-export declare const USAGE = "scriptc \u2014 TypeScript/JavaScript to native and WebAssembly executables (experimental)\n\nUsage:\n  scriptc build <file.ts|.js> [options]     compile to an executable or source artifact\n  scriptc run <file.ts|.js> [options]       compile and run\n  scriptc coverage <file.ts|.js>            how much compiles statically, and why not\n  scriptc coverage <file.ts|.js> --dynamic  what a --dynamic build compiles, and what still blocks it\n  scriptc coverage <file.ts|.js> --external-types <specifier=file.d.ts>\n                                            type-resolve an embedder-provided module for analysis\n  scriptc build --lib --profile <p.json>    library mode: compile the profile's entry\n                                            module to a linkable static archive\n                                            (<name>.lib.a) exporting the\n                                            profile-declared C symbols; a profile\n                                            with a sidecar section also gets the\n                                            contract sidecar JSON beside the archive\n  scriptc cache warm [runtime|tls|dynamic\u2026] prebuild expensive native cache families\n                                            for the current compiler/SDK/target\n\nOptions:\n  -o, --out <path>   primary output path (default: .scriptc/<name><suffix>)\n      --emit <kind>  primary output: ir, c, llvm, asm, obj, or exe\n                     (default: exe). asm/obj use the matching platform helper\n      --print <kind> print machine-readable metadata instead of the output path\n                     (native-link-info implies --emit=obj and never links)\n      --backend <b>  code generator. llvm is the default and the output that\n                     ships; c emits readable C for inspecting what the\n                     compiler produced, and program behavior is identical\n                     either way. On native targets, a program outside the LLVM tier still\n                     builds \u2014 the default lane emits C for it and a one-line\n                     stderr note names the construct \u2014 while an explicit\n                     --backend llvm fails with that construct named\n                     wasm32-wasi is LLVM-only unless --backend c is explicit;\n                     its C inspection lane accepts async-free programs only\n      --optimization <release|dev>\n                     native optimization posture (default: release/-O2). dev\n                     uses -O0, source breakpoints, and cached LLVM object shards;\n                     macOS executable builds also produce an adjacent .dSYM\n      --strip        remove symbol/debug payload from the linked executable\n                     for smaller builds (opt in; --emit=exe only)\n      --windows-subsystem <console|gui>\n                     Windows executable subsystem (default: console). gui\n                     prevents Windows from opening a console window\n      --from-c       treat input as a C (or .ll) file (toolchain plumbing/debugging)\n      --keep-c       keep the generated program TU next to the executable\n                     (default; the .ll \u2014 or the .c under --backend=c or\n                     when the build fell back)\n      --no-keep-c    delete the generated program TU after compiling\n      --emit-ir      also write IR beside an executable or library archive;\n                     deprecated for executables: use --emit=ir for primary IR\n      --sanitize     build with ASan + runtime RC audit\n      --dynamic      embed the dynamic engine (adds ~620KB; static stays the default)\n      --ffi <file>   bind signature-only TypeScript declarations to native\n                     C symbols and link the manifest's archives/libraries\n      --npm-static <pkg[,pkg\u2026]|auto>\n                     compile the named npm packages' shipped JS statically as\n                     program modules (repeatable; \"auto\" opts in every eligible\n                     direct import: own .d.ts, unminified JS, no build-transform\n                     markers). A package preflight refuses falls back to the\n                     island (--dynamic) with a coverage-report note \u2014 opt-in,\n                     experimental\n      --provenance-sources\n                     EXPERIMENTAL: compile npm dependencies from their\n                     provenance-attested SOURCE (fetched at the attested\n                     commit) as static program modules; packages without a\n                     usable attestation keep the island path (a note, never\n                     a failure)\n      --external-types <specifier=file.d.ts>\n                     coverage only: map an exact bare module specifier to a\n                     local declaration file. The declaration supplies types\n                     for analysis; the host module remains an explicit\n                     external-boundary blocker (repeatable)\n  -h, --help         show this help\n  -v, --version      print the version\n";
-export declare const CLI_OPTIONS: {
-    readonly out: {
-        readonly type: "string";
-        readonly short: "o";
-    };
-    readonly emit: {
-        readonly type: "string";
-    };
-    readonly print: {
-        readonly type: "string";
-    };
-    readonly backend: {
-        readonly type: "string";
-    };
-    readonly optimization: {
-        readonly type: "string";
-    };
-    readonly strip: {
-        readonly type: "boolean";
-        readonly default: false;
-    };
-    readonly "windows-subsystem": {
-        readonly type: "string";
-    };
-    readonly "from-c": {
-        readonly type: "boolean";
-        readonly default: false;
-    };
-    readonly "keep-c": {
-        readonly type: "boolean";
-        readonly default: true;
-    };
-    readonly "emit-ir": {
-        readonly type: "boolean";
-        readonly default: false;
-    };
-    readonly sanitize: {
-        readonly type: "boolean";
-        readonly default: false;
-    };
-    readonly dynamic: {
-        readonly type: "boolean";
-        readonly default: false;
-    };
-    readonly ffi: {
-        readonly type: "string";
-    };
-    readonly "npm-static": {
-        readonly type: "string";
-        readonly multiple: true;
-    };
-    readonly "provenance-sources": {
-        readonly type: "boolean";
-        readonly default: false;
-    };
-    readonly "external-types": {
-        readonly type: "string";
-        readonly multiple: true;
-    };
-    readonly lib: {
-        readonly type: "boolean";
-        readonly default: false;
-    };
-    readonly profile: {
-        readonly type: "string";
-    };
-    readonly help: {
-        readonly type: "boolean";
-        readonly short: "h";
-        readonly default: false;
-    };
-    readonly version: {
-        readonly type: "boolean";
-        readonly short: "v";
-        readonly default: false;
-    };
-};

package/dist/usage.js

@@ -1,97 +0,0 @@
-export const USAGE = `scriptc — TypeScript/JavaScript to native and WebAssembly executables (experimental)
-
-Usage:
-  scriptc build <file.ts|.js> [options]     compile to an executable or source artifact
-  scriptc run <file.ts|.js> [options]       compile and run
-  scriptc coverage <file.ts|.js>            how much compiles statically, and why not
-  scriptc coverage <file.ts|.js> --dynamic  what a --dynamic build compiles, and what still blocks it
-  scriptc coverage <file.ts|.js> --external-types <specifier=file.d.ts>
-                                            type-resolve an embedder-provided module for analysis
-  scriptc build --lib --profile <p.json>    library mode: compile the profile's entry
-                                            module to a linkable static archive
-                                            (<name>.lib.a) exporting the
-                                            profile-declared C symbols; a profile
-                                            with a sidecar section also gets the
-                                            contract sidecar JSON beside the archive
-  scriptc cache warm [runtime|tls|dynamic…] prebuild expensive native cache families
-                                            for the current compiler/SDK/target
-
-Options:
-  -o, --out <path>   primary output path (default: .scriptc/<name><suffix>)
-      --emit <kind>  primary output: ir, c, llvm, asm, obj, or exe
-                     (default: exe). asm/obj use the matching platform helper
-      --print <kind> print machine-readable metadata instead of the output path
-                     (native-link-info implies --emit=obj and never links)
-      --backend <b>  code generator. llvm is the default and the output that
-                     ships; c emits readable C for inspecting what the
-                     compiler produced, and program behavior is identical
-                     either way. On native targets, a program outside the LLVM tier still
-                     builds — the default lane emits C for it and a one-line
-                     stderr note names the construct — while an explicit
-                     --backend llvm fails with that construct named
-                     wasm32-wasi is LLVM-only unless --backend c is explicit;
-                     its C inspection lane accepts async-free programs only
-      --optimization <release|dev>
-                     native optimization posture (default: release/-O2). dev
-                     uses -O0, source breakpoints, and cached LLVM object shards;
-                     macOS executable builds also produce an adjacent .dSYM
-      --strip        remove symbol/debug payload from the linked executable
-                     for smaller builds (opt in; --emit=exe only)
-      --windows-subsystem <console|gui>
-                     Windows executable subsystem (default: console). gui
-                     prevents Windows from opening a console window
-      --from-c       treat input as a C (or .ll) file (toolchain plumbing/debugging)
-      --keep-c       keep the generated program TU next to the executable
-                     (default; the .ll — or the .c under --backend=c or
-                     when the build fell back)
-      --no-keep-c    delete the generated program TU after compiling
-      --emit-ir      also write IR beside an executable or library archive;
-                     deprecated for executables: use --emit=ir for primary IR
-      --sanitize     build with ASan + runtime RC audit
-      --dynamic      embed the dynamic engine (adds ~620KB; static stays the default)
-      --ffi <file>   bind signature-only TypeScript declarations to native
-                     C symbols and link the manifest's archives/libraries
-      --npm-static <pkg[,pkg…]|auto>
-                     compile the named npm packages' shipped JS statically as
-                     program modules (repeatable; "auto" opts in every eligible
-                     direct import: own .d.ts, unminified JS, no build-transform
-                     markers). A package preflight refuses falls back to the
-                     island (--dynamic) with a coverage-report note — opt-in,
-                     experimental
-      --provenance-sources
-                     EXPERIMENTAL: compile npm dependencies from their
-                     provenance-attested SOURCE (fetched at the attested
-                     commit) as static program modules; packages without a
-                     usable attestation keep the island path (a note, never
-                     a failure)
-      --external-types <specifier=file.d.ts>
-                     coverage only: map an exact bare module specifier to a
-                     local declaration file. The declaration supplies types
-                     for analysis; the host module remains an explicit
-                     external-boundary blocker (repeatable)
-  -h, --help         show this help
-  -v, --version      print the version
-`;
-export const CLI_OPTIONS = {
-    out: { type: "string", short: "o" },
-    emit: { type: "string" },
-    print: { type: "string" },
-    backend: { type: "string" },
-    optimization: { type: "string" },
-    strip: { type: "boolean", default: false },
-    "windows-subsystem": { type: "string" },
-    "from-c": { type: "boolean", default: false },
-    "keep-c": { type: "boolean", default: true },
-    "emit-ir": { type: "boolean", default: false },
-    sanitize: { type: "boolean", default: false },
-    dynamic: { type: "boolean", default: false },
-    ffi: { type: "string" },
-    "npm-static": { type: "string", multiple: true },
-    "provenance-sources": { type: "boolean", default: false },
-    "external-types": { type: "string", multiple: true },
-    lib: { type: "boolean", default: false },
-    profile: { type: "string" },
-    help: { type: "boolean", short: "h", default: false },
-    version: { type: "boolean", short: "v", default: false },
-};
-//# sourceMappingURL=usage.js.map

package/dist/usage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"usage.js","sourceRoot":"","sources":["../src/usage.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEpB,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE;IACnC,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;IACxB,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;IACzB,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;IAC3B,YAAY,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;IAChC,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;IAC1C,mBAAmB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;IACvC,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;IAC7C,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE;IAC5C,SAAS,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;IAC9C,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;IAC7C,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;IAC5C,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;IACvB,YAAY,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE;IAChD,oBAAoB,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;IACzD,gBAAgB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE;IACpD,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;IACxC,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;IAC3B,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE;IACrD,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE;CAChD,CAAC"}

package/dist/wasi-runner.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/wasi-runner.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-/* The subprocess host for `scriptc run` on wasm32-wasi. Keeping the WASI
- * instance outside the CLI process preserves native run's exit isolation:
- * process.exit(), traps, and signals cannot take the compiler process down.
- */
-import { readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { WASI } from "node:wasi";
-import { wasiGuestPath } from "@scriptc/compiler";
-import { wasiEnvironment, wasiPreopens } from "./paths.js";
-const binary = process.argv[2];
-if (binary === undefined)
-    throw new Error("scriptc WASI runner needs a module path");
-const cwd = process.cwd();
-const hostTmp = tmpdir();
-const wasi = new WASI({
-    version: "preview1",
-    args: [wasiGuestPath(binary, cwd, hostTmp) ?? binary],
-    env: wasiEnvironment(process.env, cwd, hostTmp),
-    // A native scriptc executable inherits access to the caller's filesystem.
-    // WASI is capability-based, so expose the caller's working tree as `/`
-    // and the platform's actual temporary directory as guest `/tmp`.
-    preopens: wasiPreopens(cwd, hostTmp),
-    returnOnExit: true,
-});
-const instantiated = await WebAssembly.instantiate(await readFile(binary), wasi.getImportObject());
-process.exitCode = wasi.start(instantiated.instance);
-//# sourceMappingURL=wasi-runner.js.map

package/dist/wasi-runner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wasi-runner.js","sourceRoot":"","sources":["../src/wasi-runner.ts"],"names":[],"mappings":";AACA;;;GAGG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAU3D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAC/B,IAAI,MAAM,KAAK,SAAS;IAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;AACrF,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;AAC1B,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC;AAEzB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC;IACpB,OAAO,EAAE,UAAU;IACnB,IAAI,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC;IACrD,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC;IAC/C,0EAA0E;IAC1E,uEAAuE;IACvE,iEAAiE;IACjE,QAAQ,EAAE,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC;IACpC,YAAY,EAAE,IAAI;CACnB,CAAC,CAAC;AACH,MAAM,YAAY,GAAG,MAAM,WAAW,CAAC,WAAW,CAChD,MAAM,QAAQ,CAAC,MAAM,CAAC,EACtB,IAAI,CAAC,eAAe,EAAE,CACvB,CAAC;AACF,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC"}

package/scripts/runtime-pack-host.d.mts

@@ -1,5 +0,0 @@
-export function hostSupportsRuntimePack(
-  platform?: NodeJS.Platform,
-  architecture?: string,
-  hostRelease?: string,
-): boolean;

package/scripts/runtime-pack-host.mjs

@@ -1,12 +0,0 @@
-import { release } from "node:os";
-
-export function hostSupportsRuntimePack(
-  platform = process.platform,
-  architecture = process.arch,
-  hostRelease = release(),
-) {
-  const darwinMajor = Number.parseInt(hostRelease.split(".", 1)[0] ?? "", 10);
-  return (platform === "darwin" && (architecture === "arm64" || architecture === "x64") && darwinMajor >= 24) ||
-    (platform === "linux" && (architecture === "arm64" || architecture === "x64")) ||
-    (platform === "win32" && architecture === "x64");
-}

package/scripts/warm-cache.mjs

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { hostSupportsRuntimePack } from "./runtime-pack-host.mjs";
-
-// Workspace installs should stay cheap and deterministic: repository test
-// images already manage cache warming explicitly. Published npm packages do
-// not contain src/, so only installed consumers take this best-effort path.
-const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-if (
-  !existsSync(join(packageRoot, "src")) &&
-  process.env["SCRIPTC_NO_CACHE"] !== "1" &&
-  // A supported platform install already carries immutable release/dev
-  // runtime artifacts. Unsupported hosts retain the source-toolchain path.
-  !hostSupportsRuntimePack()
-) {
-  try {
-    const { warmNativeCaches } = await import("@scriptc/compiler");
-    await warmNativeCaches();
-  } catch (error) {
-    // Installation must never depend on a native toolchain. A machine without
-    // clang/ar (or with lifecycle scripts disabled) retains ordinary lazy
-    // first-build behavior; explicit `scriptc cache warm` reports errors.
-    if (process.env["SCRIPTC_CACHE_WARM_DEBUG"] === "1") {
-      process.stderr.write(`scriptc: cache warm skipped: ${error instanceof Error ? error.message : String(error)}\n`);
-    }
-  }
-}