rastack 0.0.50 → 0.0.51

package/dist/compile/analyze.d.ts

@@ -1,6 +1,7 @@
 import * as ts from "typescript";
 import { ResourceModel } from "./model";
 import type { EntityTypeExport } from "./entities";
+export { applyTransitions } from "../define/manifest";
 /**
  * Statically analyse resource definitions and produce the canonical model.
  *
@@ -21,13 +22,6 @@ export declare function analyzeDsl(program: ts.Program, fileNames: string[]): {
     resources: ResourceModel[];
     types: EntityTypeExport[];
 };
-/**
- * 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 declare function applyTransitions(resource: ResourceModel, raw: unknown): void;
 /**
  * Evaluate a *static literal* AST node (string/number/bool/null/array/object)
  * into a JS value. Anything non-literal (a function, an identifier) yields

package/dist/compile/analyze.js

@@ -33,14 +33,20 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTransitions = void 0;
 exports.analyze = analyze;
 exports.analyzeDsl = analyzeDsl;
-exports.applyTransitions = applyTransitions;
 exports.literalToValue = literalToValue;
 const path = __importStar(require("path"));
 const ts = __importStar(require("typescript"));
 const program_1 = require("./program");
-const transitions_1 = require("../validate/transitions");
+const manifest_1 = require("../define/manifest");
+// 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.
+var manifest_2 = require("../define/manifest");
+Object.defineProperty(exports, "applyTransitions", { enumerable: true, get: function () { return manifest_2.applyTransitions; } });
 /**
  * Statically analyse resource definitions and produce the canonical model.
  *
@@ -139,35 +145,16 @@ function analyzeResourceCall(call, checker) {
         model,
         fields,
         relations,
-        sync: normaliseSync(options.sync),
-        admin: normaliseAdmin(options.admin),
+        sync: (0, manifest_1.normaliseSync)(options.sync),
+        admin: (0, manifest_1.normaliseAdmin)(options.admin),
         search: options.search,
         ordering: options.ordering,
         permission: options.permission,
-        access: normaliseAccess(options.access),
+        access: (0, manifest_1.normaliseAccess)(options.access),
     };
-    applyTransitions(resource, options.transitions);
+    (0, manifest_1.applyTransitions)(resource, options.transitions);
     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.
- */
-function applyTransitions(resource, raw) {
-    const transitions = (0, transitions_1.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.
@@ -278,46 +265,3 @@ function literalToValue(node) {
     }
     return undefined;
 }
-function normaliseSync(sync) {
-    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 = { 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) {
-    if (!access || typeof access !== "object")
-        return undefined;
-    const model = {};
-    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) => typeof g === "string");
-    }
-    return Object.keys(model).length ? model : undefined;
-}
-function normaliseAdmin(admin) {
-    if (admin === false)
-        return false;
-    if (!admin || typeof admin !== "object")
-        return undefined;
-    const model = {};
-    if (Array.isArray(admin.listDisplay))
-        model.listDisplay = admin.listDisplay;
-    return model;
-}

package/dist/define/index.d.ts

@@ -22,14 +22,31 @@
  * });
  * ```
  */
+/**
+ * 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). */
 type NullOf<O> = O extends {
@@ -37,12 +54,16 @@ type NullOf<O> = O extends {
 } ? 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 {
     maxLength?: number;
@@ -67,24 +88,24 @@ export interface DateOptions {
     null?: boolean;
 }
 /**
- * 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 declare const s: {
-    string<const O extends StringOptions = StringOptions>(_opts?: O): Scalar<"string", NullOf<O>>;
-    int<const O extends NumberOptions = NumberOptions>(_opts?: O): Scalar<"int", NullOf<O>>;
-    float<const O extends NumberOptions = NumberOptions>(_opts?: O): Scalar<"float", NullOf<O>>;
-    bool<const O extends BoolOptions = BoolOptions>(_opts?: O): Scalar<"bool", NullOf<O>>;
-    datetime<const O extends DateOptions = DateOptions>(_opts?: O): Scalar<"datetime", NullOf<O>>;
-    uuid<const O extends StringOptions = StringOptions>(_opts?: O): Scalar<"uuid", NullOf<O>>;
+    string<const O extends StringOptions = StringOptions>(opts?: O): Scalar<"string", NullOf<O>>;
+    int<const O extends NumberOptions = NumberOptions>(opts?: O): Scalar<"int", NullOf<O>>;
+    float<const O extends NumberOptions = NumberOptions>(opts?: O): Scalar<"float", NullOf<O>>;
+    bool<const O extends BoolOptions = BoolOptions>(opts?: O): Scalar<"bool", NullOf<O>>;
+    datetime<const O extends DateOptions = DateOptions>(opts?: O): Scalar<"datetime", NullOf<O>>;
+    uuid<const O extends StringOptions = StringOptions>(opts?: O): 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>): Ref<A, M>;
+    ref<A extends string, M extends string>(thunk: () => ResourceType<A, M, any>): Ref<A, M>;
 };
 export type AnyField = Scalar<string> | Ref<string, string>;
 /** Local-first sync configuration (mirrors the old Python `class Sync:`). */
@@ -229,4 +250,30 @@ export type RowOf<R> = R extends ResourceType<string, string, infer F, ResourceO
 } & {
     [K in keyof F]: FieldValueOf<F[K]>;
 } : never;
-export {};
+/** 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]>;
+};
+export { isResourceValue, manifestFromResources, resourceModel, toManifest, } from "./manifest";
+export type { AnyResourceValue, ManifestInput } from "./manifest";
+export type { Manifest, ResourceModel } from "../compile/model";

package/dist/define/index.js

@@ -24,40 +24,40 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.s = void 0;
+exports.toManifest = exports.resourceModel = exports.manifestFromResources = exports.isResourceValue = exports.s = void 0;
 exports.resource = resource;
 /**
- * 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()`.
  */
 exports.s = {
-    string(_opts) {
-        return { __rastackScalar: "string" };
+    string(opts) {
+        return { __rastackScalar: "string", options: opts };
     },
-    int(_opts) {
-        return { __rastackScalar: "int" };
+    int(opts) {
+        return { __rastackScalar: "int", options: opts };
     },
-    float(_opts) {
-        return { __rastackScalar: "float" };
+    float(opts) {
+        return { __rastackScalar: "float", options: opts };
     },
-    bool(_opts) {
-        return { __rastackScalar: "bool" };
+    bool(opts) {
+        return { __rastackScalar: "bool", options: opts };
     },
-    datetime(_opts) {
-        return { __rastackScalar: "datetime" };
+    datetime(opts) {
+        return { __rastackScalar: "datetime", options: opts };
     },
-    uuid(_opts) {
-        return { __rastackScalar: "uuid" };
+    uuid(opts) {
+        return { __rastackScalar: "uuid", options: opts };
     },
     /**
      * 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(_thunk) {
-        return { __rastackRef: true };
+    ref(thunk) {
+        return { __rastackRef: true, target: thunk };
     },
 };
 /** Define a resource. Capture app/model (and options) as literal types. */
@@ -72,3 +72,9 @@ function resource(app, model, fields, options = {}) {
         options,
     };
 }
+// The runtime manifest builder — a resource() definition is its own manifest.
+var manifest_1 = require("./manifest");
+Object.defineProperty(exports, "isResourceValue", { enumerable: true, get: function () { return manifest_1.isResourceValue; } });
+Object.defineProperty(exports, "manifestFromResources", { enumerable: true, get: function () { return manifest_1.manifestFromResources; } });
+Object.defineProperty(exports, "resourceModel", { enumerable: true, get: function () { return manifest_1.resourceModel; } });
+Object.defineProperty(exports, "toManifest", { enumerable: true, get: function () { return manifest_1.toManifest; } });

package/dist/define/manifest.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The runtime manifest builder — `resource()` definitions are their own
+ * manifest, **no `rastack compile` step required**.
+ *
+ * The DSL values carry everything the canonical manifest needs at runtime
+ * (field kinds, constraint options, FK target thunks, resource options), so
+ * this module assembles the exact `schema.rastack.json` shape the compiler
+ * emits — same fields, same relations, same normalisation — as a pure
+ * function:
+ *
+ * ```tsx
+ * import { Airport, Terminal, Flight } from "./resources/airports";
+ *
+ * <RAStackProvider mode="local" manifest={[Airport, Terminal, Flight]}>
+ * ```
+ *
+ * The compiler (`tools/src/compile/analyze.ts`) imports the option
+ * normalisers below, so the two paths cannot drift: `rastack compile` remains
+ * the way to get class/interface entities, `openapi.json`, and the artifacts
+ * the Rust backend and admin read — but the typed hooks and the in-browser
+ * engine need only this.
+ *
+ * Everything here is browser-safe: no `typescript`, no filesystem.
+ */
+import type { AccessModel, AdminModel, Manifest, ResourceModel, SyncModel } from "../compile/model";
+import type { ResourceType } from "./index";
+/** Any `resource()` value, generics erased. */
+export type AnyResourceValue = ResourceType<string, string, any, any>;
+/** Everything `toManifest()` understands — see {@link toManifest}. */
+export type ManifestInput = Manifest | object | string | AnyResourceValue | readonly AnyResourceValue[];
+/** Whether a value is a `resource()` definition. */
+export declare function isResourceValue(value: unknown): value is AnyResourceValue;
+/**
+ * One `resource()` value → its canonical {@link ResourceModel} — the same
+ * shape `rastack compile` derives from the source, produced from the runtime
+ * value instead.
+ */
+export declare function resourceModel(res: AnyResourceValue): ResourceModel;
+/**
+ * Assemble the canonical manifest from `resource()` values at runtime —
+ * accepts the values themselves, arrays of them, or whole module namespaces
+ * (`import * as resources from "./resources"`), in any mix. Output order
+ * matches the compiler's (app, then model), so the result is byte-for-byte
+ * the manifest `rastack compile` would emit for the same definitions.
+ */
+export declare function manifestFromResources(...inputs: Array<AnyResourceValue | readonly AnyResourceValue[] | Record<string, unknown>>): Manifest;
+/**
+ * Normalise anything a provider may be handed as "the manifest": a compiled
+ * manifest (object or JSON string), a `resource()` value, an array of them,
+ * or a module namespace containing them. This is what lets
+ * `<RAStackProvider manifest={[Airport, Terminal]}>` work with no compiled
+ * `schema.rastack.json` anywhere.
+ */
+export declare function toManifest(input: ManifestInput | null | undefined): Manifest | undefined;
+/**
+ * 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 declare function applyTransitions(resource: ResourceModel, raw: unknown): void;
+export declare function normaliseSync(sync: any): SyncModel | undefined;
+export declare function normaliseAccess(access: any): AccessModel | undefined;
+export declare function normaliseAdmin(admin: any): AdminModel | false | undefined;

package/dist/define/manifest.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * The runtime manifest builder — `resource()` definitions are their own
+ * manifest, **no `rastack compile` step required**.
+ *
+ * The DSL values carry everything the canonical manifest needs at runtime
+ * (field kinds, constraint options, FK target thunks, resource options), so
+ * this module assembles the exact `schema.rastack.json` shape the compiler
+ * emits — same fields, same relations, same normalisation — as a pure
+ * function:
+ *
+ * ```tsx
+ * import { Airport, Terminal, Flight } from "./resources/airports";
+ *
+ * <RAStackProvider mode="local" manifest={[Airport, Terminal, Flight]}>
+ * ```
+ *
+ * The compiler (`tools/src/compile/analyze.ts`) imports the option
+ * normalisers below, so the two paths cannot drift: `rastack compile` remains
+ * the way to get class/interface entities, `openapi.json`, and the artifacts
+ * the Rust backend and admin read — but the typed hooks and the in-browser
+ * engine need only this.
+ *
+ * Everything here is browser-safe: no `typescript`, no filesystem.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResourceValue = isResourceValue;
+exports.resourceModel = resourceModel;
+exports.manifestFromResources = manifestFromResources;
+exports.toManifest = toManifest;
+exports.applyTransitions = applyTransitions;
+exports.normaliseSync = normaliseSync;
+exports.normaliseAccess = normaliseAccess;
+exports.normaliseAdmin = normaliseAdmin;
+const transitions_1 = require("../validate/transitions");
+/** Whether a value is a `resource()` definition. */
+function isResourceValue(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        value.__rastack === "resource");
+}
+/**
+ * One `resource()` value → its canonical {@link ResourceModel} — the same
+ * shape `rastack compile` derives from the source, produced from the runtime
+ * value instead.
+ */
+function resourceModel(res) {
+    const fields = [];
+    const relations = [];
+    for (const [name, value] of Object.entries((res.fields ?? {}))) {
+        const field = runtimeField(res, name, value);
+        if (!field)
+            continue;
+        fields.push(field);
+        if (field.type === "fk" && field.relation) {
+            relations.push({
+                field: name,
+                target: `${field.relation.app}.${field.relation.model}`,
+                kind: "fk",
+            });
+        }
+    }
+    const options = (res.options ?? {});
+    const model = {
+        app: res.app,
+        model: res.model,
+        fields,
+        relations,
+        sync: normaliseSync(options.sync),
+        admin: normaliseAdmin(options.admin),
+        search: options.search,
+        ordering: options.ordering,
+        permission: options.permission,
+        access: normaliseAccess(options.access),
+    };
+    applyTransitions(model, options.transitions);
+    return model;
+}
+/** Resolve one runtime field value to its {@link FieldModel}. */
+function runtimeField(res, name, value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const field = value;
+    // Foreign key: the runtime value keeps the `() => Resource` thunk, so the
+    // relation target is recovered by calling it — the runtime twin of the
+    // compiler's "read the Ref<App, Model> type arguments" step.
+    if (field.__rastackRef === true) {
+        const target = field.target?.();
+        if (!isResourceValue(target)) {
+            throw new Error(`manifestFromResources: ${res.app}.${res.model}.${name} is an s.ref(...) whose target thunk did not return a resource() value`);
+        }
+        return {
+            name,
+            type: "fk",
+            relation: { app: target.app, model: target.model },
+        };
+    }
+    if (typeof field.__rastackScalar !== "string")
+        return undefined;
+    const model = {
+        name,
+        type: field.__rastackScalar,
+    };
+    // Constraint mapping mirrors the compiler's `applyConstraints` exactly.
+    const opts = field.options;
+    if (opts && typeof opts === "object") {
+        if (typeof opts.maxLength === "number")
+            model.maxLength = opts.maxLength;
+        if (opts.unique === true)
+            model.unique = true;
+        if (opts.primaryKey === true)
+            model.primaryKey = true;
+        if (opts.null === true)
+            model.null = true;
+        if (opts.default !== undefined)
+            model.default = opts.default;
+    }
+    return model;
+}
+/**
+ * Assemble the canonical manifest from `resource()` values at runtime —
+ * accepts the values themselves, arrays of them, or whole module namespaces
+ * (`import * as resources from "./resources"`), in any mix. Output order
+ * matches the compiler's (app, then model), so the result is byte-for-byte
+ * the manifest `rastack compile` would emit for the same definitions.
+ */
+function manifestFromResources(...inputs) {
+    const resources = collectResources(inputs).map(resourceModel);
+    resources.sort((a, b) => a.app === b.app ? a.model.localeCompare(b.model) : a.app.localeCompare(b.app));
+    return { version: 1, resources };
+}
+/** Flatten values / arrays / module namespaces into the resource list. */
+function collectResources(inputs) {
+    const out = [];
+    const seen = new Set();
+    const push = (res) => {
+        if (!seen.has(res)) {
+            seen.add(res);
+            out.push(res);
+        }
+    };
+    for (const input of inputs) {
+        if (isResourceValue(input)) {
+            push(input);
+        }
+        else if (Array.isArray(input)) {
+            for (const item of input)
+                if (isResourceValue(item))
+                    push(item);
+        }
+        else if (input && typeof input === "object") {
+            for (const item of Object.values(input)) {
+                if (isResourceValue(item))
+                    push(item);
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Normalise anything a provider may be handed as "the manifest": a compiled
+ * manifest (object or JSON string), a `resource()` value, an array of them,
+ * or a module namespace containing them. This is what lets
+ * `<RAStackProvider manifest={[Airport, Terminal]}>` work with no compiled
+ * `schema.rastack.json` anywhere.
+ */
+function toManifest(input) {
+    if (input === null || input === undefined)
+        return undefined;
+    if (typeof input === "string")
+        return JSON.parse(input);
+    if (Array.isArray(input) || isResourceValue(input)) {
+        return manifestFromResources(input);
+    }
+    const record = input;
+    // A compiled manifest passes through untouched.
+    if (Array.isArray(record.resources))
+        return input;
+    // A module namespace of resource() exports builds one.
+    const values = Object.values(record).filter(isResourceValue);
+    if (values.length)
+        return manifestFromResources(values);
+    return input;
+}
+// ---------------------------------------------------------------------------
+// Option normalisers — shared with the compiler (`compile/analyze.ts`), so
+// the runtime and compiled manifests can never disagree about a 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.
+ */
+function applyTransitions(resource, raw) {
+    const transitions = (0, transitions_1.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;
+        }
+    }
+}
+function normaliseSync(sync) {
+    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 = { 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) {
+    if (!access || typeof access !== "object")
+        return undefined;
+    const model = {};
+    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) => typeof g === "string");
+    }
+    return Object.keys(model).length ? model : undefined;
+}
+function normaliseAdmin(admin) {
+    if (admin === false)
+        return false;
+    if (!admin || typeof admin !== "object")
+        return undefined;
+    const model = {};
+    if (Array.isArray(admin.listDisplay))
+        model.listDisplay = admin.listDisplay;
+    return model;
+}