npm - numbl - Versions diffs - 0.3.3 → 0.4.1 - Mend

numbl 0.3.3 → 0.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (349) hide show

package/dist-site-viewer/coi-serviceworker.js ADDED Viewed

@@ -0,0 +1,70 @@
+/*
+ * Cross-Origin Isolation Service Worker
+ *
+ * Adds COOP/COEP headers to responses so that SharedArrayBuffer is available
+ * on hosts that don't allow custom response headers (e.g. GitHub Pages).
+ *
+ * Based on https://github.com/niccokunzmann/coi-serviceworker (MIT).
+ */
+/* global self, caches, fetch, Response, clients */
+if (typeof window === "undefined") {
+  // --- Service Worker scope ---
+  self.addEventListener("install", () => self.skipWaiting());
+  self.addEventListener("activate", event =>
+    event.waitUntil(self.clients.claim())
+  );
+  self.addEventListener("fetch", event => {
+    const request = event.request;
+    if (request.cache === "only-if-cached" && request.mode !== "same-origin") {
+      return; // Chrome bug workaround
+    }
+    // Only add isolation headers to same-origin responses.
+    // Wrapping cross-origin responses in a new Response strips CORS
+    // internal flags, which breaks cross-origin fetch requests.
+    if (new URL(request.url).origin !== self.location.origin) {
+      return; // let the browser handle cross-origin requests normally
+    }
+    event.respondWith(
+      fetch(request).then(response => {
+        if (response.status === 0) return response; // opaque response
+        const headers = new Headers(response.headers);
+        headers.set("Cross-Origin-Embedder-Policy", "credentialless");
+        headers.set("Cross-Origin-Opener-Policy", "same-origin");
+        return new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers,
+        });
+      })
+    );
+  });
+} else {
+  // --- Window scope (registration) ---
+  // Capture currentScript synchronously — it becomes null after script runs.
+  const scriptUrl = document.currentScript && document.currentScript.src;
+  if (!window.crossOriginIsolated && navigator.serviceWorker) {
+    navigator.serviceWorker.register(scriptUrl || "/coi-serviceworker.js").then(
+      reg => {
+        if (reg.installing || reg.waiting) {
+          const sw = reg.installing || reg.waiting;
+          sw.addEventListener("statechange", () => {
+            if (sw.state === "activated") window.location.reload();
+          });
+        } else if (reg.active && !navigator.serviceWorker.controller) {
+          // Active but not yet controlling — reload to let it intercept.
+          window.location.reload();
+        }
+      },
+      err => console.error("COI service worker registration failed:", err)
+    );
+  }
+}

package/dist-site-viewer/favicon.svg ADDED Viewed

@@ -0,0 +1,23 @@
+<svg width="32" height="32" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
+  <!-- Background -->
+  <rect width="32" height="32" fill="#64748b" rx="4"/>
+  <!-- Matrix brackets and dots (white on blue) -->
+  <g stroke="white" stroke-width="2" fill="none" stroke-linecap="round">
+    <!-- Left bracket -->
+    <path d="M 8 9 L 6 9 L 6 23 L 8 23"/>
+    <!-- Right bracket -->
+    <path d="M 24 9 L 26 9 L 26 23 L 24 23"/>
+  </g>
+  <!-- Matrix dots -->
+  <g fill="white">
+    <circle cx="12" cy="13" r="1.5"/>
+    <circle cx="16" cy="13" r="1.5"/>
+    <circle cx="20" cy="13" r="1.5"/>
+    <circle cx="12" cy="19" r="1.5"/>
+    <circle cx="16" cy="19" r="1.5"/>
+    <circle cx="20" cy="19" r="1.5"/>
+  </g>
+</svg>

package/dist-site-viewer/index.html ADDED Viewed

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="./favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>numbl project</title>
+    <!-- numbl:base -->
+    <script src="./coi-serviceworker.js"></script>
+    <script type="module" crossorigin src="./assets/index-C5c2lKAx.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-D5YY8PKx.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist-site-viewer/logo.svg ADDED Viewed

@@ -0,0 +1,26 @@
+<svg width="200" height="200" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+  <!-- Background circle -->
+  <circle cx="100" cy="100" r="90" fill="#64748b" opacity="0.1"/>
+  <!-- Matrix brackets (left and right) -->
+  <g stroke="#64748b" stroke-width="4" fill="none" stroke-linecap="round">
+    <!-- Left bracket -->
+    <path d="M 50 60 L 40 60 L 40 140 L 50 140"/>
+    <!-- Right bracket -->
+    <path d="M 150 60 L 160 60 L 160 140 L 150 140"/>
+  </g>
+  <!-- Matrix elements (stylized dots) -->
+  <g fill="#64748b">
+    <circle cx="70" cy="80" r="6"/>
+    <circle cx="100" cy="80" r="6"/>
+    <circle cx="130" cy="80" r="6"/>
+    <circle cx="70" cy="110" r="6"/>
+    <circle cx="100" cy="110" r="6"/>
+    <circle cx="130" cy="110" r="6"/>
+  </g>
+  <!-- Text: "Numbl" -->
+  <text x="100" y="175" font-family="sans-serif" font-size="32" font-weight="700" fill="#475569" text-anchor="middle">Numbl</text>
+</svg>

package/dist-site-viewer/numbl-embed.js ADDED Viewed

@@ -0,0 +1,111 @@
+/*
+Define a custom HTML element <numbl-embed> that embeds a numbl iframe.
+Usage:
+<numbl-embed>
+<iframe width="100%" height="500" frameborder="0"></iframe>
+<script type="text/plain" class="matlab-script">
+... MATLAB script ...
+</script>
+</numbl-embed>
+You can also specify the MATLAB script URL via attribute:
+<numbl-embed script="relative-or-absolute-url-to-matlab-script">
+<iframe width="100%" height="500" frameborder="0"></iframe>
+</numbl-embed>
+*/
+class NumblEmbed extends HTMLElement {
+  constructor() {
+    super();
+  }
+  connectedCallback() {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => this.initialize());
+    } else {
+      this.initialize();
+    }
+  }
+  initialize() {
+    this.iframe = this.querySelector("iframe");
+    if (!this.iframe) {
+      console.error("Missing iframe element in numbl-embed");
+      return;
+    }
+    const defaultNumblUrl = "https://numbl.org";
+    const numblUrl = this.attributes["numbl-url"]?.value || defaultNumblUrl;
+    const cacheBust = `_cb=${Date.now()}`;
+    const mode = this.getAttribute("mode");
+    // REPL mode: no script needed, just load the REPL page
+    if (mode === "repl") {
+      this.iframe.src = `${numblUrl}/embed-repl?${cacheBust}`;
+      return;
+    }
+    const encodePlain = text => {
+      const text2 = text.replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+      return btoa(text2);
+    };
+    const scriptElement = this.querySelector("script.matlab-script");
+    let scriptBase64;
+    if (scriptElement) {
+      const matlabScript = scriptElement.textContent.trim();
+      scriptBase64 = encodePlain(matlabScript);
+    } else if (this.attributes.script) {
+      const scriptUrl = this.attributes.script.value;
+      this.loadScriptFromUrl(scriptUrl);
+      return;
+    } else {
+      scriptBase64 = null;
+    }
+    if (scriptBase64) {
+      this.iframe.src = `${numblUrl}/embed?script=${scriptBase64}&${cacheBust}`;
+    } else {
+      this.iframe.src = `${numblUrl}/embed?${cacheBust}`;
+    }
+  }
+  async loadScriptFromUrl(url) {
+    try {
+      let absoluteUrl = url;
+      if (url.startsWith("./") || url.startsWith("../")) {
+        const baseUrl = window.location.href;
+        absoluteUrl = new URL(url, baseUrl).href;
+      }
+      const response = await fetch(absoluteUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch script: ${response.statusText}`);
+      }
+      const scriptContent = await response.text();
+      const scriptBase64 = btoa(scriptContent);
+      const defaultNumblUrl = "https://numbl.org";
+      const numblUrl = this.attributes["numbl-url"]?.value || defaultNumblUrl;
+      const cacheBust = `_cb=${Date.now()}`;
+      this.iframe.src = `${numblUrl}/embed?script=${scriptBase64}&${cacheBust}`;
+    } catch (error) {
+      console.error("Error loading MATLAB script:", error);
+      this.iframe.srcdoc = `
+        <html>
+          <body style="font-family: Arial; padding: 20px;">
+            <h3>Error loading MATLAB script</h3>
+            <p>${error.message}</p>
+          </body>
+        </html>
+      `;
+    }
+  }
+}
+customElements.define("numbl-embed", NumblEmbed);

package/dist-site-viewer/vite.svg ADDED Viewed

@@ -0,0 +1 @@

+ <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

package/native/ops/real_unary_elemwise.c CHANGED Viewed

@@ -8,7 +8,9 @@
 #include <math.h>
 static inline double rsign(double x) {
-  return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : 0.0;
+  // MATLAB: sign(NaN) is NaN; sign(0) is 0. The bare comparison chain
+  // would map NaN -> 0 (both x>0 and x<0 are false), so guard NaN first.
+  return x > 0.0 ? 1.0 : x < 0.0 ? -1.0 : (x == 0.0 ? 0.0 : NAN);
 }
 int numbl_real_unary_elemwise(int op, size_t n,

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",
@@ -33,20 +33,25 @@
     "dist-lib/",
     "dist-cli/",
     "dist-plot-viewer/",
+    "dist-site-viewer/",
     "native/",
     "binding.gyp"
   ],
   "scripts": {
-    "dev": "npm run bundle:stdlib && vite",
-    "build": "npm run build:web && npm run build:test-runner && npm run copy:test-scripts && npm run build:cli && npm run build:plot-viewer",
+    "dev": "npm run build:snippets && npm run bundle:stdlib && vite",
+    "build": "npm run build:web && npm run build:test-runner && npm run copy:test-scripts && npm run build:cli && npm run build:plot-viewer && npm run build:site-viewer",
     "build:plot-viewer": "vite build --config vite.plot-viewer.config.ts",
-    "build:test-runner": "npm run bundle:stdlib && vite build --config vite.test-runner.config.ts",
-    "dev:test-runner": "npm run bundle:stdlib && vite --config vite.test-runner.config.ts",
+    "build:site-viewer": "npm run build:snippets && npm run bundle:stdlib && vite build --config vite.site-viewer.config.ts",
+    "dev:site-viewer": "npm run build:snippets && npm run bundle:stdlib && vite --config vite.site-viewer.config.ts",
+    "build:test-runner": "npm run build:snippets && npm run bundle:stdlib && vite build --config vite.test-runner.config.ts",
+    "dev:test-runner": "npm run build:snippets && npm run bundle:stdlib && vite --config vite.test-runner.config.ts",
     "copy:test-scripts": "tsx scripts/copy-test-scripts.ts",
     "bundle:stdlib": "tsx scripts/bundle-stdlib.ts",
-    "build:web": "npm run bundle:stdlib && tsc -b && vite build",
-    "build:lib": "npm run bundle:stdlib && esbuild src/lib.ts --bundle --platform=node --format=esm --outfile=dist-lib/lib.js --packages=external --loader:.wasm=file && tsc -p tsconfig.lib.json",
-    "build:cli": "npm run bundle:stdlib && esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist-cli/cli.js --packages=external --loader:.wasm=file",
+    "build:snippets": "tsx scripts/build_runtime_snippets.ts",
+    "build:snippets:check": "tsx scripts/build_runtime_snippets.ts --check",
+    "build:web": "npm run build:snippets && npm run bundle:stdlib && tsc -b && vite build",
+    "build:lib": "npm run build:snippets && npm run bundle:stdlib && esbuild src/lib.ts --bundle --platform=node --format=esm --outfile=dist-lib/lib.js --packages=external --loader:.wasm=file && tsc -p tsconfig.lib.json",
+    "build:cli": "npm run build:snippets && npm run bundle:stdlib && esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist-cli/cli.js --packages=external --loader:.wasm=file",
     "install": "true",
     "build:addon": "node-gyp rebuild",
     "format": "prettier --write .",
@@ -58,12 +63,13 @@
     "test:coverage": "vitest run --coverage",
     "test:coverage:all": "bash scripts/coverage-all.sh",
     "test:scripts": "bash numbl_test_scripts/run_all.sh",
+    "jit-parity": "node jit_parity/run.mjs",
     "test:browser": "playwright test",
     "build:wasm": "bash numbl_test_scripts/build_wasm.sh",
     "update-readme": "tsx scripts/update-readme-usage.ts",
     "check-readme": "tsx scripts/update-readme-usage.ts --check",
     "bump": "tsx scripts/bump-version.ts",
-    "prepublishOnly": "npm run build:lib && npm run build:cli && npm run build:plot-viewer",
+    "prepublishOnly": "npm run build:lib && npm run build:cli && npm run build:plot-viewer && npm run build:site-viewer",
     "prepare": "husky"
   },
   "dependencies": {

package/dist-lib/numbl-core/executors/cJit/builtins.d.ts DELETED Viewed

@@ -1,30 +0,0 @@
-/**
- * C-JIT builtin registry — the single source of truth for which
- * builtins each C-JIT context can emit.
- *
- * Two contexts:
- *
- *   - **Elementwise** (`c-jit-fuse`, `c-jit-chain`): unary real-math
- *     builtins that compile to a single C function call inside an
- *     element-wise loop. Real-only — no complex args.
- *
- *   - **Scalar loop** (`c-jit-loop`): a superset that adds `atan2`
- *     (binary) and the complex projection builtins (`real`, `imag`,
- *     `conj`, which accept either real or complex args).
- *
- * Adding a new builtin: extend the relevant set here, make sure the
- * C name is right (override `cBuiltinName` if it differs), and add a
- * test or benchmark that exercises it. See
- * `docs/developer_reference/jit/cjit-substrate.md` for the broader
- * substrate contract.
- */
-/** Real-only unary math builtins emittable in an element-wise loop. */
-export declare const ELEMWISE_REAL_BUILTINS: ReadonlySet<string>;
-/** Real-only math builtins emittable in a scalar loop body.
- *  Superset of the elementwise set; adds `atan2` (binary). */
-export declare const LOOP_REAL_MATH_BUILTINS: ReadonlySet<string>;
-/** Projection builtins that accept real OR complex args. */
-export declare const LOOP_COMPLEX_PROJECTION_BUILTINS: ReadonlySet<string>;
-/** Map a numbl/MATLAB builtin name to its math.h C name. Identity for
- *  most; `abs` maps to `fabs` because C's `abs` is integer-typed. */
-export declare function cBuiltinName(name: string): string;

package/dist-lib/numbl-core/executors/cJit/chainCodegen.d.ts DELETED Viewed

@@ -1,59 +0,0 @@
-/**
- * c-jit-chain codegen — combine N adjacent fusable Assigns into one
- * C kernel with a single i-loop.
- *
- * Each per-name role is decided by walking the chain in source order:
- *   - input-tensor   : first occurrence is RHS, env says it's a tensor
- *   - input-scalar   : first occurrence is RHS, env says it's a scalar
- *   - local-tensor   : first occurrence is LHS (writes the value
- *                      without reading any prior value); becomes a
- *                      per-iter `double` local
- *   - input+local    : first occurrence is RHS but the chain also
- *                      writes it — read from input pointer, then
- *                      writes update the local
- *
- * Live-outs (any LHS of any Assign in the chain) get their own `double *`
- * out parameter and a writeback at the end of the loop body.
- *
- * Today: every RHS expression must be element-wise on tensors of the
- * chain's numel (scalars broadcast). The executor's propose() rejects
- * chains where this can't be guaranteed.
- *
- * ABI:
- *   void <fnName>(
- *       long n,
- *       double *out_<name1>, double *out_<name2>, ...,   // live-outs
- *       const double *in_<nameA>, const double *in_<nameB>, ...,
- *       double <nameC>, double <nameD>, ...);
- */
-import type { ChainAnalysis } from "./chainPass.js";
-/** Per-name role (decided at compile time using env types). */
-export type NameRole = {
-    kind: "input-tensor";
-} | {
-    kind: "input-scalar";
-} | {
-    kind: "local-tensor";
-    readsFromInput: boolean;
-};
-/** Resolved per-name info carried from compile() into codegen. */
-export interface ChainResolution {
-    /** Role for every name referenced in the chain. */
-    readonly roles: ReadonlyMap<string, NameRole>;
-    /** Names whose final value is live-out (written somewhere in the
-     *  chain). For Phase A: every Assign LHS is conservatively
-     *  live-out. */
-    readonly liveOuts: readonly string[];
-    /** Tensor input names in stable order (for koffi declaration). */
-    readonly tensorInputs: readonly string[];
-    /** Scalar input names in stable order. */
-    readonly scalarInputs: readonly string[];
-}
-/** Decide each name's role from the AST + a "is this var a tensor?"
- *  classifier. Returns null if any per-stmt structure is incompatible
- *  with the codegen — caller should bail. */
-export declare function resolveChain(cls: ChainAnalysis, isTensor: (name: string) => boolean | null): ChainResolution | null;
-/** Build the koffi function declaration string. */
-export declare function buildChainDeclaration(fnName: string, res: ChainResolution): string;
-/** Emit the C source. */
-export declare function generateChainCSource(fnName: string, cls: ChainAnalysis, res: ChainResolution): string;

package/dist-lib/numbl-core/executors/cJit/chainExecutor.d.ts DELETED Viewed

@@ -1,27 +0,0 @@
-/**
- * c-jit-chain — element-wise chain executor.
- *
- *   - `propose()` filters on Synth stmts with `tag === "c-jit-chain"`.
- *     Reads each tensor input's `numel` from env and verifies they
- *     all match. Declines below `CHAIN_MIN_NUMEL`.
- *
- *   - `compile()` resolves per-name roles using runtime env types,
- *     emits the combined C kernel, builds the koffi declaration,
- *     calls compileAndLoad. Surfaces source via `interp.onCJitCompile`.
- *
- *   - `run()` gathers tensor data + scalars, allocates one
- *     `Float64Array(numel)` per live-out, invokes the kernel, writes
- *     each live-out back to env as a `RuntimeTensor` with the input
- *     tensors' shape.
- */
-import type { Executor } from "../types.js";
-import type { SynthLoweredStmt } from "../lowering.js";
-import { type ChainResolution } from "./chainCodegen.js";
-import { type CompiledC } from "./compile.js";
-interface ChainCompiled {
-    readonly compiled: CompiledC;
-    readonly resolution: ChainResolution;
-    readonly source: string;
-}
-export declare const cJitChainExecutor: Executor<SynthLoweredStmt, ChainCompiled | null>;
-export {};

package/dist-lib/numbl-core/executors/cJit/chainPass.d.ts DELETED Viewed

@@ -1,42 +0,0 @@
-/**
- * c-jit-chain AST transformer.
- *
- * Walks a stmt list once and identifies maximal contiguous runs of
- * adjacent stmts that are individually candidates for fusion (today:
- * tensor element-wise Assigns whose RHS is a fusable expression
- * tree). Wraps each non-trivial run (length >= 2) in a `Synth` node
- * with `tag: "c-jit-chain"`; the matching `cJitChainExecutor` will
- * compile the whole chain to one C kernel at dispatch time.
- *
- * Singletons (chains of length 1) are left as the original Assign so
- * the existing `c-jit-fuse` per-stmt path handles them. That keeps
- * the win path narrow: chains exist only where multiple adjacent
- * fusable Assigns can amortize per-call overhead and share memory
- * traversal.
- *
- * Purely structural — no env access. Runtime decisions (size,
- * type-shape match) happen in the executor's `propose()`.
- *
- * Recursive descent: For/While/If bodies are transformed lazily via
- * `Registry.transformStmts` when the interpreter walks them. This
- * pass just operates on the immediate stmt list.
- */
-import { type Stmt } from "../../parser/types.js";
-/** Per-stmt classification used by the chain executor. The data
- *  carried on each Synth node is `ChainAnalysis`. */
-export interface ChainAnalysis {
-    /** Original Assigns in source order. */
-    readonly assigns: readonly (Stmt & {
-        type: "Assign";
-    })[];
-    /** Stable shape hash — combines per-stmt RHS structures and LHS
-     *  names, used by the executor's cacheKey. Sizes / runtime types
-     *  are NOT included; those affect cost, not codegen shape. */
-    readonly cacheKey: string;
-}
-/**
- * Transform a stmt list, wrapping maximal fusable runs (length >= 2)
- * in `Synth` nodes. Returns a new list when any transformation
- * happens; returns the input unchanged otherwise.
- */
-export declare function chainPass(stmts: readonly Stmt[]): Stmt[];

package/dist-lib/numbl-core/executors/cJit/codegen.d.ts DELETED Viewed

@@ -1,44 +0,0 @@
-/**
- * c-jit-loop codegen — JIT IR → C source.
- *
- * Emits one C function per loop. Each scalar variable is encoded
- * either as a single `double` (real) or a pair `<name>_re`, `<name>_im`
- * (complex). Inputs are passed by value (real → 1 arg, complex →
- * 2 args); outputs are written through a `double *out` pointer
- * (real → 1 slot, complex → 2 slots).
- *
- * Codegen is deliberately narrow — see `whitelist.ts` for the set of
- * IR nodes accepted. Anything outside that set is a programming error
- * here (the executor's `propose()` must reject before reaching this
- * module).
- */
-import type { JitStmt, JitType } from "../../jitTypes.js";
-/** Per-variable C encoding. */
-export type VarEncoding = "real" | "complex";
-/** Resolved (input + local) variable types. Codegen keys lookups on
- *  the variable name; both Vars and Assigns consult this map. */
-export type VarTypeMap = ReadonlyMap<string, VarEncoding>;
-/** Emitted scalar value. Real values are a single C expression;
- *  complex values are a (re, im) pair. */
-export type Emitted = {
-    kind: "real";
-    expr: string;
-} | {
-    kind: "complex";
-    re: string;
-    im: string;
-};
-/** Walk the IR + input typings and produce a per-name encoding map.
- *  A name is "complex" iff at least one read or write of it has a
- *  complex_or_number type. Otherwise "real".
- *
- *  This mirrors the JIT's type widening: by the time the IR is
- *  produced, every Var / Assign for the same name has been unified
- *  to a single type. The walker just records that type. */
-export declare function inferVarEncodings(inputs: readonly string[], inputTypes: readonly JitType[], body: readonly JitStmt[]): Map<string, VarEncoding>;
-/** Per-variable slot count in the marshaling ABI: real → 1, complex → 2. */
-export declare function varSlotCount(enc: VarEncoding): number;
-/** Total number of `double` slots a variable list consumes. */
-export declare function totalSlotCount(names: readonly string[], varTypes: VarTypeMap): number;
-/** Emit a complete C source file. */
-export declare function generateCSource(fnName: string, inputs: readonly string[], outputs: readonly string[], body: readonly JitStmt[], varTypes: VarTypeMap): string;

package/dist-lib/numbl-core/executors/cJit/compile.d.ts DELETED Viewed

@@ -1,45 +0,0 @@
-/**
- * c-jit compile + cache + load.
- *
- * Cache layout: `~/.cache/numbl/c-jit/<sha>.so` (one per unique
- * (declaration, source) pair). On hit, dlopen and reuse — no `cc`
- * invocation. On miss, write `<sha>.c`, exec `cc`, dlopen.
- *
- * The koffi function declaration is fully owned by the caller —
- * different executors (c-jit-loop, c-jit-fuse, ...) emit the
- * declaration that matches their ABI. This module only handles
- * source-string-in / koffi-callable-out.
- */
-import type { NativeBridge } from "../../workspace/types.js";
-/**
- * The koffi function reference returned by `lib.func(decl)`. The
- * actual call signature is controlled by the caller's declaration —
- * type as variadic and let the caller cast as needed.
- */
-export type CFn = (...args: unknown[]) => unknown;
-export interface CompiledC {
-    readonly fn: CFn;
-    /** Path to the .so on disk — useful for diagnostics. */
-    readonly libPath: string;
-    /** Cache hit (true) vs. fresh cc invocation (false). */
-    readonly cacheHit: boolean;
-}
-export interface CompileOptions {
-    /** Enable `-ffast-math`. On by default for ~30% speedup on
-     *  element-wise tensor benchmarks (libmvec vectorization of
-     *  transcendentals). Opt out via the CLI's `--no-fast-math` flag
-     *  to keep FP semantics bitwise-deterministic. */
-    readonly fastMath?: boolean;
-}
-/**
- * Compile (or look up cached) and load. The cache key is the SHA of
- * `(declaration, source)` so the same source compiled with different
- * koffi declarations gets distinct cache entries (defensive — usually
- * the declaration matches the source's signature).
- */
-export declare function compileAndLoad(source: string, declaration: string, bridge: NativeBridge, options?: CompileOptions): CompiledC;
-/**
- * Read a previously-compiled C source from disk. Diagnostic helper
- * for verifying cache hits.
- */
-export declare function readCachedSource(hash: string): string | null;

package/dist-lib/numbl-core/executors/cJit/elemwiseCodegen.d.ts DELETED Viewed

@@ -1,23 +0,0 @@
-/**
- * Shared codegen helpers for the element-wise C-JIT executors
- * (`c-jit-fuse`, `c-jit-chain`).
- *
- * Both executors lower the same AST subset (the one accepted by
- * `elemwiseStructural.isElemwiseStructuralExpr`) to C; they only
- * differ in how an `Ident` leaf maps to a C expression (tensor pointer
- * indexing vs. local-name vs. scalar parameter). This module owns the
- * shared structural emitter and a few utility helpers; the per-executor
- * codegen is reduced to a thin wrapper that supplies the leaf mapping.
- */
-import { type Expr } from "../../parser/types.js";
-/** Emit a C `double` literal that's unambiguous to the compiler.
- *  Handles NaN, ±Inf, integer-valued doubles. */
-export declare function formatDouble(v: number): string;
-/** Walk `e` and add every `Ident` name to `out`. Whitelisted to the
- *  element-wise AST subset — anything outside (e.g. `Index`) is a
- *  programming error (the structural classifier should have rejected). */
-export declare function collectIdents(e: Expr, out: Set<string>): void;
-/** Lower an element-wise AST expression to a C string. The caller
- *  supplies `identToC` to map each `Ident` name to its in-loop C form
- *  (e.g. `t0[i]`, `in_x[i]`, `s2`, or a bare local name). */
-export declare function emitElemwiseExpr(e: Expr, identToC: (name: string) => string): string;

package/dist-lib/numbl-core/executors/cJit/elemwiseStructural.d.ts DELETED Viewed

@@ -1,33 +0,0 @@
-/**
- * Shared structural classifier for element-wise C-JIT.
- *
- * The "is this AST expression element-wise lowerable?" check, in two
- * pieces:
- *
- *   - `isElemwiseStructuralExpr(e)` — fully structural, no env access.
- *     Used by `chainPass` (runs at stmt-list-entry time, before env
- *     types are known).
- *
- *   - `isElemwiseBinaryOp(op)` / `binaryOpNeedsScalarCheck(op)` — the
- *     binary-op subset, exposed so env-aware walkers (`fuseAnalyze`)
- *     can apply runtime-scalar checks on top of the structural shape.
- *
- * Pairs with `builtins.ts` (which owns the unary builtin set). Anything
- * not accepted here is rejected at propose-time.
- */
-import { BinaryOperation, type Expr, UnaryOperation } from "../../parser/types.js";
-/** Binary ops the element-wise codegen can emit. `Mul`/`Div` are matrix
- *  ops in MATLAB but degenerate to element-wise when at least one
- *  operand is a scalar — env-aware callers should additionally apply
- *  `binaryOpNeedsScalarCheck`. */
-export declare function isElemwiseBinaryOp(op: BinaryOperation): boolean;
-/** True iff `op` requires a runtime scalar-operand check before being
- *  emitted element-wise (i.e. plain `*` and `/`). */
-export declare function binaryOpNeedsScalarCheck(op: BinaryOperation): boolean;
-/** Unary ops the element-wise codegen can emit. */
-export declare function isElemwiseUnaryOp(op: UnaryOperation): boolean;
-/** Structural check: is `e` element-wise lowerable as a tree shape?
- *  Does NOT consult env. Leaves (`Ident`, `Number`) are accepted
- *  unconditionally; runtime classification of identifiers (tensor vs.
- *  scalar) is the caller's responsibility. */
-export declare function isElemwiseStructuralExpr(e: Expr): boolean;