rastack 0.0.50 → 0.0.51

package/hooks/entity.ts

@@ -27,6 +27,7 @@ import type {
   TransitionsModel,
 } from "../src/compile/model";
 import type { ResourceType, RowOf } from "../src/define";
+import { isResourceValue, resourceModel } from "../src/define/manifest";
 import type { EntityTypes } from "./registry";
 import { normalizeTransitions } from "../src/validate/transitions";
 
@@ -46,7 +47,9 @@ export type EntityRef<TRow = any> =
  * The row type an entity reference implies — every reference form infers:
  * classes carry it (`InstanceType`), `resource()` values derive it from their
  * fields ({@link RowOf}), and `"app.model"` strings resolve through the
- * {@link EntityTypes} registry `rastack compile` emits (`rastack-env.d.ts`).
+ * {@link EntityTypes} registry — populated by a one-line hand-written
+ * `EntityTypesOf<…>` declaration, or by the `rastack-env.d.ts` that
+ * `rastack compile` emits. No path involves generated runtime code.
  */
 export type EntityRow<E> =
   E extends EntityClass<infer R>
@@ -116,7 +119,10 @@ export function resolveEntityRef(
   manifest?: Manifest,
 ): ResolvedEntity {
   // `{ app, model }` — a `resource()` value, an EntityDescriptor, or a plain
-  // object. The manifest enriches it (fields, transitions) when available.
+  // object. The manifest enriches it (fields, transitions) when available;
+  // a `resource()` value that a manifest doesn't cover is **its own
+  // manifest** — the definition carries its fields/options at runtime, so no
+  // compile step (and no provider config) is needed for the DSL path.
   if (typeof ref === "object" && ref !== null) {
     const { app, model } = ref as { app?: unknown; model?: unknown };
     if (typeof app !== "string" || typeof model !== "string") {
@@ -124,9 +130,9 @@ export function resolveEntityRef(
         "useData/useForm: an object entity reference needs string `app` and `model` properties",
       );
     }
-    const resource = manifest?.resources.find(
-      (r) => r.app === app && r.model === model,
-    );
+    const resource =
+      manifest?.resources.find((r) => r.app === app && r.model === model) ??
+      (isResourceValue(ref) ? resourceModel(ref) : undefined);
     const opts = (ref as { options?: { transitions?: unknown } }).options;
     return resolved(app, model, resource, opts?.transitions);
   }

package/hooks/form/entity-form.ts

@@ -51,11 +51,8 @@ import {
 import { useRastackManifest } from "../manifest";
 import type { EntityTypes, RegisteredEntityKey } from "../registry";
 import { writeSchema } from "../../src/compile/openapi";
-import type {
-  FieldModel,
-  Manifest,
-  ResourceModel,
-} from "../../src/compile/model";
+import type { FieldModel, ResourceModel } from "../../src/compile/model";
+import { toManifest, type ManifestInput } from "../../src/define/manifest";
 import {
   allowedTransitions,
   applyTransition,
@@ -71,8 +68,11 @@ export interface UseEntityFormOptions<TRow> {
   /** `"put"` to save with PUT; default is POST on create / PATCH on update. */
   updateType?: FormUpdate;
   onSuccess?: (row: TRow) => void;
-  /** Manifest override — tests, or callers outside `<RAStackProvider>`. */
-  manifest?: Manifest;
+  /**
+   * Manifest override — tests, or callers outside `<RAStackProvider>`.
+   * Accepts a compiled manifest or `resource()` definitions (array/module).
+   */
+  manifest?: ManifestInput;
 }
 
 /** One transition available from the record's current state. */
@@ -144,7 +144,11 @@ export function useEntityForm<TRow = any, TName extends string = string>(
   options: UseEntityFormOptions<TRow> = {},
 ): EntityFormResult<TRow, TName> {
   const contextManifest = useRastackManifest();
-  const manifest = options.manifest ?? contextManifest;
+  const optionManifest = useMemo(
+    () => toManifest(options.manifest),
+    [options.manifest],
+  );
+  const manifest = optionManifest ?? contextManifest;
   const resolvedEntity = useMemo(
     () => resolveEntityRef(entity, manifest),
     [entity, manifest],

package/hooks/manifest.ts

@@ -1,11 +1,14 @@
 /**
- * The compiled manifest (`schema.rastack.json`) as React context — what lets
- * `useData(Airport)` / `useForm(Flight)` resolve a plain TypeScript type to
- * its resource at runtime with no generated code in between.
+ * The manifest as React context — what lets `useData(Airport)` /
+ * `useForm(Flight)` resolve a plain TypeScript type to its resource at
+ * runtime with no generated code in between.
  *
  * `<RAStackProvider manifest={…}>` supplies it (in every mode — the manifest
  * is required for the WASM engine anyway, and in `remote` mode it is the only
- * piece of compiler output the client needs). Hooks read it with
+ * schema the client needs). It accepts the compiled `schema.rastack.json`
+ * (object or JSON string) **or the `resource()` definitions themselves** — an
+ * array, or a whole module namespace — in which case the manifest is built at
+ * runtime and no compile step is involved. Hooks read it with
  * {@link useRastackManifest}; tests and one-off callers can bypass the context
  * by passing `manifest` directly in a hook's options.
  */
@@ -13,29 +16,62 @@
 import { createContext, createElement, useContext, useMemo } from "react";
 import type { ReactNode } from "react";
 import type { Manifest } from "../src/compile/model";
+import { toManifest, type ManifestInput } from "../src/define/manifest";
 
 export const RastackManifestContext = createContext<Manifest | undefined>(
   undefined,
 );
 
 export interface RastackManifestProviderProps {
-  /** `schema.rastack.json` — parsed object or JSON string. */
-  manifest?: Manifest | object | string;
+  /**
+   * `schema.rastack.json` (parsed object or JSON string), or `resource()`
+   * definitions (an array or a module namespace) to build it from at runtime.
+   */
+  manifest?: ManifestInput;
   children?: ReactNode;
 }
 
-/** Provide the compiled manifest to every `useData`/`useForm` beneath it. */
+/** Provide the manifest to every `useData`/`useForm` beneath it. */
 export function RastackManifestProvider(props: RastackManifestProviderProps) {
   const { manifest, children } = props;
-  const value = useMemo<Manifest | undefined>(() => {
-    if (manifest === undefined || manifest === null) return undefined;
-    if (typeof manifest === "string") return JSON.parse(manifest) as Manifest;
-    return manifest as Manifest;
-  }, [manifest]);
+  const value = useMemo<Manifest | undefined>(
+    () => toManifest(manifest) ?? getGlobalManifest(),
+    [manifest],
+  );
   return createElement(RastackManifestContext.Provider, { value }, children);
 }
 
-/** The compiled manifest, when a provider supplies one. */
+/**
+ * The manifest in effect: the nearest provider's, else the one the dev-server
+ * plugin registered globally (see {@link getGlobalManifest}) — which is what
+ * lets an app pass **no manifest anywhere**.
+ */
 export function useRastackManifest(): Manifest | undefined {
-  return useContext(RastackManifestContext);
+  return useContext(RastackManifestContext) ?? getGlobalManifest();
+}
+
+// -- the auto-registered manifest -------------------------------------------
+
+/**
+ * The global the `rastack/plugin` dev-server plugin assigns before the app
+ * boots (its injected register module runs first): the manifest compiled
+ * from your TypeScript entities, refreshed on every save. With it in place,
+ * `<RAStackProvider mode="local">` needs no `manifest` prop and `useData` /
+ * `useForm` resolve entities with zero schema wiring in app code — the
+ * types are the only thing you author.
+ */
+export const GLOBAL_MANIFEST_KEY = "__RASTACK_MANIFEST__";
+
+let cachedRaw: unknown;
+let cachedManifest: Manifest | undefined;
+
+/** The plugin-registered manifest, normalised (and cached per assignment). */
+export function getGlobalManifest(): Manifest | undefined {
+  const raw = (globalThis as Record<string, unknown>)[GLOBAL_MANIFEST_KEY];
+  if (raw === undefined || raw === null) return undefined;
+  if (raw !== cachedRaw) {
+    cachedRaw = raw;
+    cachedManifest = toManifest(raw as ManifestInput);
+  }
+  return cachedManifest;
 }

package/hooks/registry.ts

@@ -7,8 +7,27 @@
  *
  * TypeScript can't conjure an interface out of a string on its own, so the
  * registry maps manifest keys (`"app.model"`) to your own types via ordinary
- * declaration merging. **You don't write it by hand**: `rastack compile`
- * emits `rastack-env.d.ts` alongside the manifest —
+ * declaration merging. Note that classes and `resource()` values never need
+ * it — they infer on their own; the registry only serves the string form.
+ * Two ways to populate it, **neither generating runtime code**:
+ *
+ * 1. **Hand-written, no compile step** — point `EntityTypesOf` at your
+ *    resources module once; it derives every `"app.model"` key and row type
+ *    from the definitions and tracks them forever:
+ *
+ * ```ts
+ * // rastack-env.d.ts — written once by you, never regenerated
+ * import type { EntityTypesOf } from "rastack/define";
+ * declare module "rastack/hooks/registry" {
+ *   interface EntityTypes
+ *     extends EntityTypesOf<typeof import("./resources/airports")> {}
+ * }
+ * ```
+ *
+ * 2. **Emitted by `rastack compile`** as `rastack-env.d.ts` beside the
+ *    manifest — one entry per class/interface entity in the compiled graph
+ *    (which have no runtime value for `EntityTypesOf` to read), pointing at
+ *    *your* declaration:
  *
  * ```ts
  * declare module "rastack/hooks/registry" {
@@ -18,12 +37,10 @@
  * }
  * ```
  *
- * — one entry per class/interface entity in the compiled graph, pointing at
- * *your* declaration (types only, no runtime code, nothing to import). With
- * the file in the program, `useData` / `useRecord` / `useForm` overloads
- * resolve `"app.model"` arguments through {@link EntityTypes}; unregistered
- * strings fall back to `any` (or an explicit `useData<ITerminal>(…)`
- * argument, which always still works).
+ * With either file in the program, `useData` / `useRecord` / `useForm`
+ * overloads resolve `"app.model"` arguments through {@link EntityTypes};
+ * unregistered strings fall back to `any` (or an explicit
+ * `useData<ITerminal>(…)` argument, which always still works).
  */
 
 /** `"app.model"` → row type. Populated by declaration merging — see above. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rastack",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "description": "",
   "main": "runtime.ts",
   "types": "runtime.ts",

package/plugin.ts

@@ -0,0 +1,8 @@
+/**
+ * `rastack/plugin` — the dev-server schema compiler. Add it to the bundler
+ * you already run (Vite/Rollup: `rastackPlugin()`; anything else:
+ * `startRastackWatcher()`) and class/interface entities compile to the
+ * manifest on every save — no `rastack compile` command in the loop.
+ * Node-only: import from build config, never from app code.
+ */
+export * from "./src/plugin";

package/provider/provider.tsx

@@ -33,6 +33,8 @@ import {
   isAccessRevoked,
   purgeIdentityCache,
 } from "../cache";
+import { toManifest } from "../src/define/manifest";
+import { getGlobalManifest } from "../hooks/manifest";
 
 const RastackContext = createContext<RastackClient | null>(null);
 
@@ -57,6 +59,16 @@ export function RAStackProvider({
   const persistRef = useRef<(() => void) & { flush: () => void }>();
   const cacheStorageRef = useRef<CacheStorage | null>(null);
 
+  // The `manifest` prop is optional: when the rastack dev-server plugin is
+  // in the bundler it registers the compiled schema globally before the app
+  // boots, so `<RAStackProvider mode="local">` needs no schema wiring at
+  // all. An explicit prop (schema.rastack.json object/string, or resource()
+  // definitions — array or module namespace) always wins.
+  const manifest = useMemo(
+    () => toManifest(config.manifest) ?? getGlobalManifest(),
+    [config.manifest],
+  );
+
   const setStatusSafe = (next: RadStatus) => {
     setStatus(next);
     config.onStatusChange?.(next);
@@ -110,15 +122,17 @@ export function RAStackProvider({
       }
 
       // -- WASM modes (local / s3) --
-      if (!config.manifest) {
-        throw new Error("RAStackProvider: `manifest` is required in local/s3 mode.");
+      if (!manifest) {
+        throw new Error(
+          "RAStackProvider: no manifest found for local/s3 mode — add rastackPlugin() to your bundler (rastack/plugin), or pass the `manifest` prop.",
+        );
       }
 
       setStatusSafe("loading");
       const loader = config.loadEngine ?? defaultEngineLoader;
       const mod = await loader();
       if (cancelled) return;
-      const engine = createEngine(mod, config.manifest, config.openapi);
+      const engine = createEngine(mod, manifest, config.openapi);
 
       // Run the in-browser engine as the signed-in identity so owner stamping
       // and row-level security match the server exactly.
@@ -140,7 +154,7 @@ export function RAStackProvider({
           await engine.importWarehouse(existing);
         } else {
           const base = config.warehouseBaseUrl ?? "/data/warehouse/";
-          const resources = manifestResources(config.manifest);
+          const resources = manifestResources(manifest);
           if (config.cache === false) {
             await seedFromIceberg(engine, base, resources);
           } else {
@@ -230,7 +244,7 @@ export function RAStackProvider({
 
   return (
     <RastackContext.Provider value={client}>
-      <RastackManifestProvider manifest={config.manifest}>
+      <RastackManifestProvider manifest={manifest}>
         {children}
       </RastackManifestProvider>
     </RastackContext.Provider>

package/provider/types.ts

@@ -98,12 +98,19 @@ export interface RAStackProviderConfig {
 
   // -- all modes --
   /**
-   * `schema.rastack.json` — object or JSON string. Required for WASM modes
-   * (it drives the in-browser engine), and recommended in `remote` mode too:
-   * it is what lets the generic `useData(Entity)` / `useForm(Entity)` hooks
-   * resolve a plain TypeScript type to its resource at runtime.
+   * The schema — **usually omitted**: with the `rastack/plugin` dev-server
+   * plugin in the bundler, the manifest compiled from your entities is
+   * registered globally before the app boots and the provider picks it up
+   * automatically. Pass it explicitly to override: the compiled
+   * `schema.rastack.json` (object or JSON string), the
+   * `virtual:rastack-manifest` module, or `resource()` definitions (an array
+   * or a module namespace), from which the provider builds the identical
+   * manifest at runtime. One of the two (plugin or prop) is required for
+   * WASM modes (the manifest drives the in-browser engine); it is also what
+   * lets `useData(Entity)` / `useForm(Entity)` resolve a plain TypeScript
+   * type to its resource at runtime.
    */
-  manifest?: object | string;
+  manifest?: object | readonly object[] | string;
   /** `openapi.json` — object or JSON string. Optional (`/api/schema/`). */
   openapi?: object | string;
   /**

package/src/compile/analyze.ts

@@ -1,18 +1,26 @@
 import * as path from "path";
 import * as ts from "typescript";
 import {
-  AccessModel,
-  AdminModel,
   FieldModel,
   RelationModel,
   ResourceModel,
   ScalarType,
-  SyncModel,
 } from "./model";
 import { resourceSourceFiles } from "./program";
-import { normalizeTransitions } from "../validate/transitions";
+import {
+  applyTransitions,
+  normaliseAccess,
+  normaliseAdmin,
+  normaliseSync,
+} from "../define/manifest";
 import type { EntityTypeExport } from "./entities";
 
+// The option normalisers live beside the runtime manifest builder
+// (`define/manifest.ts`) and are shared with it, so a manifest built from
+// runtime `resource()` values and one compiled from the same source can
+// never disagree. Re-exported here for existing importers.
+export { applyTransitions } from "../define/manifest";
+
 /**
  * Statically analyse resource definitions and produce the canonical model.
  *
@@ -147,26 +155,6 @@ function analyzeResourceCall(
   return resource;
 }
 
-/**
- * Attach a normalised `transitions` block to a resource and derive what the
- * machine implies about its state field: the `states` become the field's
- * allowed-value set (`enum` in OpenAPI, the `member` gate in validation), and
- * `initial` becomes its default when the field doesn't declare one.
- */
-export function applyTransitions(resource: ResourceModel, raw: unknown): void {
-  const transitions = normalizeTransitions(raw);
-  if (!transitions) return;
-  resource.transitions = transitions;
-
-  const stateField = resource.fields.find((f) => f.name === transitions.field);
-  if (stateField && stateField.type !== "fk") {
-    stateField.options = [...transitions.states];
-    if (stateField.default === undefined && transitions.initial !== undefined) {
-      stateField.default = transitions.initial;
-    }
-  }
-}
-
 /**
  * Resolve a single field from its initializer. FK detection is type-driven:
  * the initializer's *type* is inspected, and a `Ref` type yields a foreign key.
@@ -280,41 +268,3 @@ export function literalToValue(node: ts.Expression | undefined): any {
   }
   return undefined;
 }
-
-function normaliseSync(sync: any): SyncModel | undefined {
-  if (!sync || typeof sync !== "object") return undefined;
-  const mode = sync.mode === "local" ? "local" : "server";
-  if (mode === "server" && !sync.confirmed) {
-    // A bare server resource carries no sync semantics.
-    return undefined;
-  }
-  const model: SyncModel = { mode };
-  if (typeof sync.scope === "string") model.scope = sync.scope;
-  if (Array.isArray(sync.confirmed)) model.confirmed = sync.confirmed;
-  if (sync.load === "lazy") model.load = "lazy";
-  if (sync.clientIds === true) model.clientIds = true;
-  return model;
-}
-
-function normaliseAccess(access: any): AccessModel | undefined {
-  if (!access || typeof access !== "object") return undefined;
-  const model: AccessModel = {};
-  if (typeof access.ownerField === "string") model.ownerField = access.ownerField;
-  if (access.scope === "owner" || access.scope === "shared") {
-    model.scope = access.scope;
-  }
-  if (Array.isArray(access.adminGroups)) {
-    model.adminGroups = access.adminGroups.filter(
-      (g: unknown) => typeof g === "string",
-    );
-  }
-  return Object.keys(model).length ? model : undefined;
-}
-
-function normaliseAdmin(admin: any): AdminModel | false | undefined {
-  if (admin === false) return false;
-  if (!admin || typeof admin !== "object") return undefined;
-  const model: AdminModel = {};
-  if (Array.isArray(admin.listDisplay)) model.listDisplay = admin.listDisplay;
-  return model;
-}

package/src/define/index.ts

@@ -23,14 +23,32 @@
  * ```
  */
 
+/**
+ * Every constraint a scalar builder may be handed, merged — the shape the
+ * runtime value carries so a manifest can be assembled without the compiler.
+ */
+export interface ScalarFieldOptions {
+  maxLength?: number;
+  unique?: boolean;
+  primaryKey?: boolean;
+  default?: unknown;
+  null?: boolean;
+  autoNow?: boolean;
+  autoNowAdd?: boolean;
+}
+
 /**
  * A scalar field. The literal `__rastackScalar` type is what the compiler
  * reads; `Nullable` phantom-carries the `null: true` option so {@link RowOf}
- * can add `| null` to the inferred row type.
+ * can add `| null` to the inferred row type. The authored options ride along
+ * on the runtime value too, so `manifestFromResources()` can build the same
+ * manifest `rastack compile` emits — with no compile step at all.
  */
 export interface Scalar<T extends string, Nullable extends boolean = boolean> {
   readonly __rastackScalar: T;
   readonly __rastackNullable?: Nullable;
+  /** The constraint options as authored — carried at runtime. */
+  readonly options?: ScalarFieldOptions;
 }
 
 /** Whether an options literal declares `null: true` (as a type). */
@@ -38,12 +56,16 @@ type NullOf<O> = O extends { null: true } ? true : false;
 
 /**
  * A foreign-key field. `App`/`Model` are carried as string-literal type
- * arguments so the compiler can recover the relation target purely from types.
+ * arguments so the compiler can recover the relation target purely from
+ * types; the target thunk is *also* kept on the runtime value so
+ * `manifestFromResources()` can recover the relation with no compiler.
  */
 export interface Ref<App extends string, Model extends string> {
   readonly __rastackRef: true;
   readonly __app: App;
   readonly __model: Model;
+  /** The authored `() => Resource` thunk — carried at runtime. */
+  readonly target?: () => ResourceType<App, Model, any>;
 }
 
 export interface StringOptions {
@@ -73,51 +95,66 @@ export interface DateOptions {
 }
 
 /**
- * Field builders. Each returns a phantom value whose *type* encodes the field
- * kind; the runtime object is never used at compile time (the compiler analyses
- * the source, it does not execute it) but is real so the DSL is also usable at
- * runtime if a consumer wants it.
+ * Field builders. Each returns a value whose *type* encodes the field kind
+ * (what the compiler reads — it analyses the source, it does not execute it)
+ * and whose runtime shape keeps the authored options/target, so the same
+ * definition doubles as its own manifest via `manifestFromResources()`.
  */
 export const s = {
   string<const O extends StringOptions = StringOptions>(
-    _opts?: O,
+    opts?: O,
   ): Scalar<"string", NullOf<O>> {
-    return { __rastackScalar: "string" } as Scalar<"string", NullOf<O>>;
+    return { __rastackScalar: "string", options: opts } as Scalar<
+      "string",
+      NullOf<O>
+    >;
   },
   int<const O extends NumberOptions = NumberOptions>(
-    _opts?: O,
+    opts?: O,
   ): Scalar<"int", NullOf<O>> {
-    return { __rastackScalar: "int" } as Scalar<"int", NullOf<O>>;
+    return { __rastackScalar: "int", options: opts } as Scalar<"int", NullOf<O>>;
   },
   float<const O extends NumberOptions = NumberOptions>(
-    _opts?: O,
+    opts?: O,
   ): Scalar<"float", NullOf<O>> {
-    return { __rastackScalar: "float" } as Scalar<"float", NullOf<O>>;
+    return { __rastackScalar: "float", options: opts } as Scalar<
+      "float",
+      NullOf<O>
+    >;
   },
   bool<const O extends BoolOptions = BoolOptions>(
-    _opts?: O,
+    opts?: O,
   ): Scalar<"bool", NullOf<O>> {
-    return { __rastackScalar: "bool" } as Scalar<"bool", NullOf<O>>;
+    return { __rastackScalar: "bool", options: opts } as Scalar<
+      "bool",
+      NullOf<O>
+    >;
   },
   datetime<const O extends DateOptions = DateOptions>(
-    _opts?: O,
+    opts?: O,
   ): Scalar<"datetime", NullOf<O>> {
-    return { __rastackScalar: "datetime" } as Scalar<"datetime", NullOf<O>>;
+    return { __rastackScalar: "datetime", options: opts } as Scalar<
+      "datetime",
+      NullOf<O>
+    >;
   },
   uuid<const O extends StringOptions = StringOptions>(
-    _opts?: O,
+    opts?: O,
   ): Scalar<"uuid", NullOf<O>> {
-    return { __rastackScalar: "uuid" } as Scalar<"uuid", NullOf<O>>;
+    return { __rastackScalar: "uuid", options: opts } as Scalar<
+      "uuid",
+      NullOf<O>
+    >;
   },
   /**
    * A foreign key. The target is `() => SomeResource`; the compiler resolves
-   * the relation from the *type* `Ref<App, Model>` this returns — it does not
-   * need to run the thunk.
+   * the relation from the *type* `Ref<App, Model>` this returns, and the
+   * runtime keeps the thunk so `manifestFromResources()` can resolve it too.
    */
   ref<A extends string, M extends string>(
-    _thunk: () => ResourceType<A, M, any>,
+    thunk: () => ResourceType<A, M, any>,
   ): Ref<A, M> {
-    return { __rastackRef: true } as Ref<A, M>;
+    return { __rastackRef: true, target: thunk } as Ref<A, M>;
   },
 };
 
@@ -310,3 +347,42 @@ export type RowOf<R> =
   R extends ResourceType<string, string, infer F, ResourceOptions>
     ? { id: number | string } & { [K in keyof F]: FieldValueOf<F[K]> }
     : never;
+
+/** The `"app.model"` registry key a `resource()` definition implies. */
+export type EntityKeyOf<R> =
+  R extends ResourceType<infer A, infer M, any, ResourceOptions>
+    ? `${A}.${M}`
+    : never;
+
+/**
+ * The `EntityTypes` registry entries a module of `resource()` definitions
+ * implies — the *hand-written* alternative to the `rastack-env.d.ts` that
+ * `rastack compile` emits. Point it at your resources module once and the
+ * registry tracks it forever, with no compile step in the loop:
+ *
+ * ```ts
+ * // rastack-env.d.ts — written once by you, never regenerated
+ * import type { EntityTypesOf } from "rastack/define";
+ * declare module "rastack/hooks/registry" {
+ *   interface EntityTypes
+ *     extends EntityTypesOf<typeof import("./resources/airports")> {}
+ * }
+ * ```
+ *
+ * Non-resource exports are dropped, so `typeof import("…")` over a whole
+ * module is safe. (Class entities carry their own row type — they never need
+ * the registry; interfaces still register via the compile-emitted file.)
+ */
+export type EntityTypesOf<M> = {
+  [K in keyof M as EntityKeyOf<M[K]>]: RowOf<M[K]>;
+};
+
+// The runtime manifest builder — a resource() definition is its own manifest.
+export {
+  isResourceValue,
+  manifestFromResources,
+  resourceModel,
+  toManifest,
+} from "./manifest";
+export type { AnyResourceValue, ManifestInput } from "./manifest";
+export type { Manifest, ResourceModel } from "../compile/model";