rastack 0.0.22 → 0.0.23

package/dist/compile/index.js

@@ -36,8 +36,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOpenApi = exports.buildManifest = exports.analyze = void 0;
+exports.buildOpenApi = exports.buildManifest = exports.detectCycles = exports.analyzeEntities = exports.analyze = void 0;
 exports.resolveResourceFiles = resolveResourceFiles;
+exports.analyzeProject = analyzeProject;
 exports.analyzeResources = analyzeResources;
 exports.compile = compile;
 exports.collisions = collisions;
@@ -45,11 +46,15 @@ exports.urlsFor = urlsFor;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const analyze_1 = require("./analyze");
+const entities_1 = require("./entities");
 const manifest_1 = require("./manifest");
 const openapi_1 = require("./openapi");
 const program_1 = require("./program");
 var analyze_2 = require("./analyze");
 Object.defineProperty(exports, "analyze", { enumerable: true, get: function () { return analyze_2.analyze; } });
+var entities_2 = require("./entities");
+Object.defineProperty(exports, "analyzeEntities", { enumerable: true, get: function () { return entities_2.analyzeEntities; } });
+Object.defineProperty(exports, "detectCycles", { enumerable: true, get: function () { return entities_2.detectCycles; } });
 var manifest_2 = require("./manifest");
 Object.defineProperty(exports, "buildManifest", { enumerable: true, get: function () { return manifest_2.buildManifest; } });
 var openapi_2 = require("./openapi");
@@ -60,18 +65,19 @@ const IGNORE_DIRS = new Set([
     "node_modules",
     ".git",
     ".expo",
-    ".rad",
+    ".rad", // legacy output dir
+    ".rastack",
     "dist",
     "web-build",
 ]);
 /**
- * Every `.ts` resource file under a directory (recursively), or an explicit
- * file. Recursion is what lets resource definitions live **co-located with the
- * pages that consume them** — e.g. `app/airports/_schema.rad.ts` beside
- * `app/airports/index.tsx` — instead of in one top-level `resources/` folder.
- * `.tsx` route components and `.d.ts` files are skipped; only files with a
- * `resource(...)` call contribute to the manifest, so co-located helpers are
- * harmless.
+ * Every `.ts`/`.tsx` source file under a directory (recursively), or an
+ * explicit file. Recursion is what lets resource definitions live **co-located
+ * with the pages that consume them** — e.g. `app/airports/_schema.rastack.ts`
+ * beside `app/airports/index.tsx` — instead of in one top-level `resources/`
+ * folder. `.tsx` files carry no `resource(...)` definitions but are scanned
+ * for the typed hook calls (`useEntityList<Airport>(…)`) that root the
+ * interface-driven entity graph; co-located helpers are harmless.
  */
 function resolveResourceFiles(input) {
     const stat = fs.existsSync(input) ? fs.statSync(input) : undefined;
@@ -85,7 +91,7 @@ function resolveResourceFiles(input) {
                     if (!IGNORE_DIRS.has(entry.name))
                         walk(path.join(dir, entry.name));
                 }
-                else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+                else if (/\.tsx?$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
                     files.push(path.resolve(dir, entry.name));
                 }
             }
@@ -95,23 +101,49 @@ function resolveResourceFiles(input) {
     }
     throw new Error(`No such resources path: ${input}`);
 }
-/** Analyse resource definitions into the canonical model (no file output). */
-function analyzeResources(input) {
+/**
+ * Analyse a project into the canonical model: explicit `resource()` DSL
+ * definitions plus resources inferred from hook-rooted TypeScript interfaces.
+ * When both surfaces define the same `app.model`, the explicit DSL definition
+ * wins — hook usage of a generated `IAirport` interface resolves back onto the
+ * authored resource instead of creating a duplicate. Cycle detection runs over
+ * the merged FK graph.
+ */
+function analyzeProject(input) {
     const files = resolveResourceFiles(input);
     const program = (0, program_1.createProgram)(files);
-    return (0, analyze_1.analyze)(program, files);
+    const fromDsl = (0, analyze_1.analyze)(program, files);
+    const fromInterfaces = (0, entities_1.analyzeEntities)(program, files);
+    const defined = new Set(fromDsl.map((r) => `${r.app}.${r.model}`));
+    const resources = [
+        ...fromDsl,
+        ...fromInterfaces.resources.filter((r) => !defined.has(`${r.app}.${r.model}`)),
+    ];
+    resources.sort((a, b) => a.app === b.app ? a.model.localeCompare(b.model) : a.app.localeCompare(b.app));
+    return {
+        resources,
+        diagnostics: [...fromInterfaces.diagnostics, ...(0, entities_1.detectCycles)(resources)],
+    };
+}
+/** Analyse resource definitions into the canonical model (no file output). */
+function analyzeResources(input) {
+    return analyzeProject(input).resources;
 }
 /** Compile resource definitions to a manifest + OpenAPI, writing both to disk. */
 function compile(input, outDir) {
-    const resources = analyzeResources(input);
+    const { resources, diagnostics } = analyzeProject(input);
+    const errors = diagnostics.filter((d) => d.severity === "error");
+    if (errors.length) {
+        throw new Error(errors.map((e) => e.message).join("\n"));
+    }
     const manifest = (0, manifest_1.buildManifest)(resources);
     const openapi = (0, openapi_1.buildOpenApi)(resources);
     fs.mkdirSync(outDir, { recursive: true });
-    const manifestPath = path.join(outDir, "schema.rad.json");
+    const manifestPath = path.join(outDir, "schema.rastack.json");
     const openapiPath = path.join(outDir, "openapi.json");
     fs.writeFileSync(manifestPath, (0, manifest_1.manifestToJson)(manifest), { flag: "w" });
     fs.writeFileSync(openapiPath, (0, openapi_1.openApiToJson)(openapi), { flag: "w" });
-    return { manifest, openapi, files: [manifestPath, openapiPath] };
+    return { manifest, openapi, files: [manifestPath, openapiPath], diagnostics };
 }
 // -- introspection (replaces `manage.py rastack check|list|urls`) -----------
 /** Detect duplicate `app.model` definitions and dangling FK targets. */

package/dist/compile/model.d.ts

@@ -1,6 +1,6 @@
 /**
  * The canonical, backend-agnostic data model produced by the compiler. This is
- * what `schema.rad.json` serializes and what both the OpenAPI emitter and the
+ * what `schema.rastack.json` serializes and what both the OpenAPI emitter and the
  * Rust API consume.
  */
 export type ScalarType = "string" | "int" | "float" | "bool" | "datetime" | "uuid";
@@ -38,7 +38,7 @@ export interface AdminModel {
     listDisplay?: string[];
 }
 /**
- * Row-level access control, enforced by `rad-api-core` on every surface.
+ * Row-level access control, enforced by `rastack-api-core` on every surface.
  * `ownerField` names the field stamped with the authenticated subject;
  * `scope: "owner"` places the table under a per-identity warehouse prefix
  * (`tenants/{sub}/…`) so object-storage IAM can fence data per user.

package/dist/compile/model.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * The canonical, backend-agnostic data model produced by the compiler. This is
- * what `schema.rad.json` serializes and what both the OpenAPI emitter and the
+ * what `schema.rastack.json` serializes and what both the OpenAPI emitter and the
  * Rust API consume.
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compile/program.d.ts

@@ -1,7 +1,8 @@
 import * as ts from "typescript";
 /**
  * Build a `ts.Program` (and thus a `TypeChecker`) over a set of resource
- * definition files. The DSL package (`rad-tools/define`) is mapped to the
+ * definition files. The authoring subpaths (`rastack/define` for the DSL,
+ * `rastack/types` for the `DbConfig` column brands) are mapped to the
  * in-tree/installed sources via `paths` so both the shipped package name and
  * the local demo/tests resolve without extra linking.
  */

package/dist/compile/program.js

@@ -39,7 +39,8 @@ const path = __importStar(require("path"));
 const ts = __importStar(require("typescript"));
 /**
  * Build a `ts.Program` (and thus a `TypeChecker`) over a set of resource
- * definition files. The DSL package (`rad-tools/define`) is mapped to the
+ * definition files. The authoring subpaths (`rastack/define` for the DSL,
+ * `rastack/types` for the `DbConfig` column brands) are mapped to the
  * in-tree/installed sources via `paths` so both the shipped package name and
  * the local demo/tests resolve without extra linking.
  */
@@ -53,10 +54,14 @@ function createProgram(fileNames) {
         skipLibCheck: true,
         esModuleInterop: true,
         noEmit: true,
+        // `.tsx` app files are scanned for the typed hook calls that root the
+        // interface-driven entity graph.
+        jsx: ts.JsxEmit.ReactJSX,
         baseUrl: process.cwd(),
         paths: {
-            "rad-tools/define": [defineDir],
-            "rad-tools/define/*": [defineDir + "/*"],
+            "rastack/define": [defineDir],
+            "rastack/define/*": [defineDir + "/*"],
+            "rastack/types": [path.join(defineDir, "db")],
         },
     };
     return ts.createProgram(fileNames, options);

package/dist/csv-schema.js

@@ -29,7 +29,7 @@ const DEFAULT_PII_PATTERNS = [
     "*income*",
 ];
 function loadPiiConfig(repoRoot) {
-    const configPath = path_1.default.join(repoRoot, ".rad", "pii-patterns.yml");
+    const configPath = path_1.default.join(repoRoot, ".rastack", "pii-patterns.yml");
     if (!fs_1.default.existsSync(configPath)) {
         return { patterns: DEFAULT_PII_PATTERNS, luhn_check: true, require_policy: true };
     }

package/dist/define/db.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Type-level column configuration for interface-driven entities.
+ *
+ * Interface entities are plain TypeScript, so their column constraints are
+ * expressed *in the type system*: intersect a property type with one or more
+ * {@link DbConfig} brands and the compiler reads the configuration straight
+ * off the type — the same way it reads foreign keys.
+ *
+ * ```ts
+ * import { Default, Int, MaxLength, PrimaryKey, Unique, UUID } from "rastack/types";
+ *
+ * export interface Passenger {
+ *   id: UUID & PrimaryKey;
+ *   seat: string & MaxLength<4> & Unique;
+ *   age: Int;                          // number maps to float; Int refines it
+ *   status: string & Default<"active">;
+ * }
+ * ```
+ *
+ * Recurring configurations can extend {@link DbConfig} once and be reused:
+ *
+ * ```ts
+ * interface Registration extends DbConfig<{ maxLength: 10; unique: true }> {}
+ *
+ * export interface Aircraft {
+ *   registration: string & Registration;
+ * }
+ * ```
+ *
+ * The brands are "flavors", not hard brands: the phantom `__rastackDb` property is
+ * optional and never exists at runtime, so a plain `"3F"` stays assignable to
+ * `string & MaxLength<4> & Unique` — no casts anywhere in app code.
+ */
+/**
+ * The phantom carrier every constraint type extends. `C` holds the column
+ * configuration as literal types; the compiler recovers it from the `__rastackDb`
+ * property of the intersected field type.
+ */
+export interface DbConfig<C = unknown> {
+    readonly __rastackDb?: C;
+}
+/** The column value must be unique. */
+export interface Unique extends DbConfig<{
+    unique: true;
+}> {
+}
+/** The column is the primary key. */
+export interface PrimaryKey extends DbConfig<{
+    primaryKey: true;
+}> {
+}
+/** Maximum length for string columns: `string & MaxLength<120>`. */
+export interface MaxLength<N extends number> extends DbConfig<{
+    maxLength: N;
+}> {
+}
+/** Server-side default value: `string & Default<"scheduled">`, `number & Default<0>`. */
+export interface Default<V extends string | number | boolean> extends DbConfig<{
+    default: V;
+}> {
+}
+/** An integer column — a bare `number` property maps to `float`. */
+export type Int = number & DbConfig<{
+    int: true;
+}>;
+/** A UUID column, stored as a string. */
+export type UUID = string & DbConfig<{
+    uuid: true;
+}>;
+/** A datetime column authored as a string (a `Date` property maps directly). */
+export type DateTimeString = string & DbConfig<{
+    datetime: true;
+}>;

package/dist/define/db.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Type-level column configuration for interface-driven entities.
+ *
+ * Interface entities are plain TypeScript, so their column constraints are
+ * expressed *in the type system*: intersect a property type with one or more
+ * {@link DbConfig} brands and the compiler reads the configuration straight
+ * off the type — the same way it reads foreign keys.
+ *
+ * ```ts
+ * import { Default, Int, MaxLength, PrimaryKey, Unique, UUID } from "rastack/types";
+ *
+ * export interface Passenger {
+ *   id: UUID & PrimaryKey;
+ *   seat: string & MaxLength<4> & Unique;
+ *   age: Int;                          // number maps to float; Int refines it
+ *   status: string & Default<"active">;
+ * }
+ * ```
+ *
+ * Recurring configurations can extend {@link DbConfig} once and be reused:
+ *
+ * ```ts
+ * interface Registration extends DbConfig<{ maxLength: 10; unique: true }> {}
+ *
+ * export interface Aircraft {
+ *   registration: string & Registration;
+ * }
+ * ```
+ *
+ * The brands are "flavors", not hard brands: the phantom `__rastackDb` property is
+ * optional and never exists at runtime, so a plain `"3F"` stays assignable to
+ * `string & MaxLength<4> & Unique` — no casts anywhere in app code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/define/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * rad-tools authoring DSL — the TypeScript-first source of truth.
+ * rastack authoring DSL — the TypeScript-first source of truth.
  *
  * Resources are authored as plain TypeScript. The compiler
  * (`tools/src/compile`) reads these definitions and, crucially, **infers
@@ -9,7 +9,7 @@
  * `Ref`'s string-literal type arguments.
  *
  * ```ts
- * import { resource, s } from "rad-tools/define";
+ * import { resource, s } from "rastack/define";
  *
  * export const Airport = resource("airports", "airport", {
  *   code: s.string({ maxLength: 3, unique: true }),
@@ -22,16 +22,16 @@
  * });
  * ```
  */
-/** A scalar field. The literal `__radScalar` type is what the compiler reads. */
+/** A scalar field. The literal `__rastackScalar` type is what the compiler reads. */
 export interface Scalar<T extends string> {
-    readonly __radScalar: T;
+    readonly __rastackScalar: T;
 }
 /**
  * A foreign-key field. `App`/`Model` are carried as string-literal type
  * arguments so the compiler can recover the relation target purely from types.
  */
 export interface Ref<App extends string, Model extends string> {
-    readonly __radRef: true;
+    readonly __rastackRef: true;
     readonly __app: App;
     readonly __model: Model;
 }
@@ -87,8 +87,8 @@ export interface SyncOptions {
     clientIds?: boolean;
 }
 /**
- * Row-level access control. Enforced by `rad-api-core`, so the rules are
- * identical on the server (Lambda / `rad serve`) and in the in-browser WASM
+ * Row-level access control. Enforced by `rastack-api-core`, so the rules are
+ * identical on the server (Lambda / `rastack serve`) and in the in-browser WASM
  * engine.
  *
  * - `ownerField` — the field that records the owning identity (the verified
@@ -126,7 +126,7 @@ export interface ResourceOptions {
  * arguments so a {@link Ref} to this resource carries a recoverable target.
  */
 export interface ResourceType<App extends string, Model extends string, F> {
-    readonly __rad: "resource";
+    readonly __rastack: "resource";
     readonly __app: App;
     readonly __model: Model;
     readonly app: App;

package/dist/define/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * rad-tools authoring DSL — the TypeScript-first source of truth.
+ * rastack authoring DSL — the TypeScript-first source of truth.
  *
  * Resources are authored as plain TypeScript. The compiler
  * (`tools/src/compile`) reads these definitions and, crucially, **infers
@@ -10,7 +10,7 @@
  * `Ref`'s string-literal type arguments.
  *
  * ```ts
- * import { resource, s } from "rad-tools/define";
+ * import { resource, s } from "rastack/define";
  *
  * export const Airport = resource("airports", "airport", {
  *   code: s.string({ maxLength: 3, unique: true }),
@@ -34,22 +34,22 @@ exports.resource = resource;
  */
 exports.s = {
     string(_opts) {
-        return { __radScalar: "string" };
+        return { __rastackScalar: "string" };
     },
     int(_opts) {
-        return { __radScalar: "int" };
+        return { __rastackScalar: "int" };
     },
     float(_opts) {
-        return { __radScalar: "float" };
+        return { __rastackScalar: "float" };
     },
     bool(_opts) {
-        return { __radScalar: "bool" };
+        return { __rastackScalar: "bool" };
     },
     datetime(_opts) {
-        return { __radScalar: "datetime" };
+        return { __rastackScalar: "datetime" };
     },
     uuid(_opts) {
-        return { __radScalar: "uuid" };
+        return { __rastackScalar: "uuid" };
     },
     /**
      * A foreign key. The target is `() => SomeResource`; the compiler resolves
@@ -57,13 +57,13 @@ exports.s = {
      * need to run the thunk.
      */
     ref(_thunk) {
-        return { __radRef: true };
+        return { __rastackRef: true };
     },
 };
 /** Define a resource. Capture app/model as literal types for FK inference. */
 function resource(app, model, fields, options = {}) {
     return {
-        __rad: "resource",
+        __rastack: "resource",
         __app: app,
         __model: model,
         app,

package/dist/index.js

@@ -11,7 +11,7 @@ const args = process.argv.slice(2);
 const schemaOnly = args.includes("--schema-only");
 const currentDir = process.cwd(); // Get the current working directory
 const kodeDir = path_1.default.join(currentDir, ".kode");
-const configFile = path_1.default.join(kodeDir, "generate-rad-sdk.json");
+const configFile = path_1.default.join(kodeDir, "generate-rastack-sdk.json");
 let config = {};
 // Create the .kode directory if it doesn't exist
 if (!fs_1.default.existsSync(kodeDir)) {

package/dist/rastack-compile.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * `rastack compile | check | list | urls` — the TypeScript-first replacement for the
+ * old Django `manage.py rastack` command.
+ *
+ *   rastack compile [resourcesDir] [outDir]   defs → schema.rastack.json + openapi.json
+ *   rastack check   [resourcesDir]            validate the resource graph (exit != 0 on error)
+ *   rastack list    [resourcesDir]            print every resource + its fields/relations
+ *   rastack urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
+ */
+export {};

package/dist/{rad-compile.js → rastack-compile.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * `rad compile | check | list | urls` — the TypeScript-first replacement for the
+ * `rastack compile | check | list | urls` — the TypeScript-first replacement for the
  * old Django `manage.py rastack` command.
  *
- *   rad compile [resourcesDir] [outDir]   defs → schema.rad.json + openapi.json
- *   rad check   [resourcesDir]            validate the resource graph (exit != 0 on error)
- *   rad list    [resourcesDir]            print every resource + its fields/relations
- *   rad urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
+ *   rastack compile [resourcesDir] [outDir]   defs → schema.rastack.json + openapi.json
+ *   rastack check   [resourcesDir]            validate the resource graph (exit != 0 on error)
+ *   rastack list    [resourcesDir]            print every resource + its fields/relations
+ *   rastack urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const compile_1 = require("./compile");
 const DEFAULT_RESOURCES = "resources";
-const DEFAULT_OUT = ".rad";
+const DEFAULT_OUT = ".rastack";
 function main(argv) {
     const [sub, ...rest] = argv;
     switch (sub) {
@@ -20,12 +20,22 @@ function main(argv) {
             const resourcesDir = rest[0] || DEFAULT_RESOURCES;
             const outDir = rest[1] || DEFAULT_OUT;
             const result = (0, compile_1.compile)(resourcesDir, outDir);
+            for (const d of result.diagnostics)
+                console.warn(`  ⚠ ${d.message}`);
             console.log(`✓ compiled ${result.manifest.resources.length} resource(s) → ${result.files.join(", ")}`);
             break;
         }
         case "check": {
-            const resources = (0, compile_1.analyzeResources)(rest[0] || DEFAULT_RESOURCES);
-            const errors = (0, compile_1.collisions)(resources);
+            const { resources, diagnostics } = (0, compile_1.analyzeProject)(rest[0] || DEFAULT_RESOURCES);
+            const errors = [
+                ...(0, compile_1.collisions)(resources),
+                ...diagnostics
+                    .filter((d) => d.severity === "error")
+                    .map((d) => d.message),
+            ];
+            for (const d of diagnostics.filter((d) => d.severity === "warning")) {
+                console.warn(`  ⚠ ${d.message}`);
+            }
             if (errors.length) {
                 for (const e of errors)
                     console.error(`  ✗ ${e}`);
@@ -70,10 +80,10 @@ function main(argv) {
         default:
             console.error(`Unknown compile subcommand: "${sub}"\n\n` +
                 `Usage:\n` +
-                `  rad compile [resourcesDir] [outDir]\n` +
-                `  rad check   [resourcesDir]\n` +
-                `  rad list    [resourcesDir]\n` +
-                `  rad urls    [resourcesDir]\n`);
+                `  rastack compile [resourcesDir] [outDir]\n` +
+                `  rastack check   [resourcesDir]\n` +
+                `  rastack list    [resourcesDir]\n` +
+                `  rastack urls    [resourcesDir]\n`);
             process.exit(1);
     }
 }

package/dist/{rad-wasm-build.d.ts → rastack-wasm-build.d.ts}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 /**
- * `rad wasm` — compile the Rust API to WebAssembly for in-browser local dev.
+ * `rastack wasm` — compile the Rust API to WebAssembly for in-browser local dev.
  *
  * Pipeline:
  *   1. cargo build -p rad-wasm --release --target wasm32-unknown-unknown
- *   2. wasm-bindgen --target web  → stack/wasm/rad_wasm.js + rad_wasm_bg.wasm
+ *   2. wasm-bindgen --target web  → stack/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
  *   3. wasm-opt -Oz (if available) to shrink the binary
  *
  * The generated bundle is what `<RAStackProvider mode="local">` loads. Prereqs:

package/dist/{rad-wasm-build.js → rastack-wasm-build.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * `rad wasm` — compile the Rust API to WebAssembly for in-browser local dev.
+ * `rastack wasm` — compile the Rust API to WebAssembly for in-browser local dev.
  *
  * Pipeline:
  *   1. cargo build -p rad-wasm --release --target wasm32-unknown-unknown
- *   2. wasm-bindgen --target web  → stack/wasm/rad_wasm.js + rad_wasm_bg.wasm
+ *   2. wasm-bindgen --target web  → stack/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
  *   3. wasm-opt -Oz (if available) to shrink the binary
  *
  * The generated bundle is what `<RAStackProvider mode="local">` loads. Prereqs:
@@ -22,7 +22,7 @@ const path_1 = __importDefault(require("path"));
 const repoRoot = path_1.default.resolve(__dirname, "..", "..");
 const rustDir = path_1.default.join(repoRoot, "rust");
 const outDir = path_1.default.join(repoRoot, "tools", "wasm");
-const wasmPath = path_1.default.join(rustDir, "target", "wasm32-unknown-unknown", "release", "rad_wasm.wasm");
+const wasmPath = path_1.default.join(rustDir, "target", "wasm32-unknown-unknown", "release", "rastack_wasm.wasm");
 function run(cmd, args, cwd = repoRoot) {
     // Local build tool: `cmd`/`args` are the fixed toolchain invocations below
     // (cargo, wasm-bindgen, wasm-opt), not untrusted input — no injection surface.
@@ -65,7 +65,7 @@ run("wasm-bindgen", [
     "--out-dir",
     outDir,
     "--out-name",
-    "rad_wasm",
+    "rastack_wasm",
     wasmPath,
 ]);
 // Mark the emitted bundle as ESM so Node and bundlers treat it correctly
@@ -73,11 +73,11 @@ run("wasm-bindgen", [
 fs_1.default.writeFileSync(path_1.default.join(outDir, "package.json"), JSON.stringify({ type: "module", sideEffects: false }, null, 2) + "\n");
 if (has("wasm-opt")) {
     console.log("→ wasm-opt -Oz");
-    const bg = path_1.default.join(outDir, "rad_wasm_bg.wasm");
+    const bg = path_1.default.join(outDir, "rastack_wasm_bg.wasm");
     run("wasm-opt", ["-Oz", "-o", bg, bg]);
 }
 else {
     console.log("· wasm-opt not found — skipping size optimisation (optional)");
 }
-const size = fs_1.default.statSync(path_1.default.join(outDir, "rad_wasm_bg.wasm")).size;
+const size = fs_1.default.statSync(path_1.default.join(outDir, "rastack_wasm_bg.wasm")).size;
 console.log(`✓ wasm engine built: stack/wasm/ (${(size / 1024).toFixed(0)} KB)`);

package/dist/rastack.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * rastack — unified CLI for React API Stack
+ *
+ * Commands:
+ *   rastack compile [resourcesDir] [outDir]     TypeScript resources → schema.rastack.json + openapi.json
+ *   rastack check   [resourcesDir]              Validate the resource graph
+ *   rastack list    [resourcesDir]              Print resources, fields and relations
+ *   rastack urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes
+ *   rastack generate [--schema-only]            Generate typed hooks from OpenAPI
+ *   rastack serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
+ *   rastack admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
+ *   rastack wasm                                Compile the API to WebAssembly (in-browser local dev)
+ *   rastack scan   [files...] [--fail-on-pii]   Scan CSVs for PII and schema info
+ *   rastack seed   [--env dev] [--source gs://] Load CSVs into Iceberg namespace
+ */
+export {};