@fougere/core 0.1.0-alpha.0

package/dist/orm.d.ts

@@ -0,0 +1,96 @@
+import type { SchemaLike } from '@fougere/schema';
+/** Options for list queries — pagination, sorting, counting. */
+export interface ListOptions {
+    /** Number of records to return. */
+    limit?: number;
+    /** Offset-based: skip N records. */
+    offset?: number;
+    /** Page-based: 1-indexed page number (requires limit). */
+    page?: number;
+    /** Cursor-based: fetch records after this ID. */
+    after?: string;
+    /** Field name to order by. */
+    orderBy?: string;
+    /** Sort direction (default: 'asc'). */
+    order?: 'asc' | 'desc';
+    /** If true, also returns total count (for pagination UIs). */
+    count?: boolean;
+    /**
+     * Equality criteria, field by field — `{ orderId: '…' }`. Named rather than spread
+     * across the options so an unknown key stays ignored instead of silently becoming a
+     * filter. `listBy(criteria)` is the same thing said as an intention.
+     */
+    where?: Record<string, unknown>;
+}
+/** Result of list() — extends Array so it's backward compatible. */
+export interface ListResult<T> extends Array<T> {
+    /** Total number of matching records (only set when count: true). */
+    total?: number;
+    /** Cursor of the last item (for cursor-based pagination). */
+    endCursor?: string;
+    /** Whether more records exist after endCursor. */
+    hasMore?: boolean;
+}
+/**
+ * The keys `list()` answers to. Anything else is a mistake, and saying so is the point:
+ * the façade refuses an unknown key in a CLIENT's input (`Unknown field`) — this applies the
+ * same rule to the framework's own arguments. `list({ orderId })` used to be accepted and
+ * the filter dropped, so a one-to-many relation quietly returned the whole table.
+ */
+export declare const LIST_OPTION_KEYS: readonly ["limit", "offset", "page", "after", "orderBy", "order", "count", "where", "select"];
+/** Refuse an option the port does not answer to, naming it and what was expected. */
+export declare function assertListOptions(options: object | undefined, entity: string): void;
+/** Select option — restrict returned fields to those of a SchemaLike. */
+export interface SelectOption {
+    select?: SchemaLike;
+}
+/** Per-entity ORM — scoped CRUD operations on a single entity type. */
+export interface EntityOrm<T = Record<string, unknown>> {
+    list(options?: ListOptions & SelectOption): Promise<ListResult<T>>;
+    findById(id: string, options?: SelectOption): Promise<T | undefined>;
+    /**
+     * Read by criteria — `findBy({ email })` for the one, `findAllBy({ orderId })` for the
+     * many, which is what a one-to-many relation *is*.
+     *
+     * Both existed on the SQL implementation from the start and neither was declared here.
+     * A port that hides what it offers is a port nobody can use: `auth-better` cast its way
+     * in (`orm as OrmWithFindBy`), a presenter that needed the lines of an order read the
+     * whole table instead, and the GraphQL relation resolver passed criteria to `list()`
+     * — which drops what it does not know.
+     */
+    findBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption): Promise<T | undefined>;
+    findAllBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption): Promise<T[]>;
+    create(input: Partial<T>, options?: SelectOption): Promise<T>;
+    update(id: string, input: Partial<T>, options?: SelectOption): Promise<T>;
+    delete(id: string): Promise<boolean>;
+    /** Returns a scoped ORM that restricts all read results to the fields of the given schema. */
+    output(schema: SchemaLike): EntityOrm<T>;
+    /**
+     * What this ORM wraps — the Kysely instance for the SQL one, something else elsewhere.
+     *
+     * Every judge sits on the ORM's own methods, so a statement issued here meets none of
+     * them: a value the entity refuses lands in the table without a word. It is the port's
+     * own escape hatch rather than a handle on the side, so it keeps the scope the container
+     * gave you — `productOrm.client` reaches the products, not the whole database.
+     *
+     * `unknown` on purpose: the client belongs to the implementation, and narrowing it is
+     * the caller saying out loud which one they are standing on.
+     */
+    readonly client: unknown;
+}
+/**
+ * Factory that creates an EntityOrm for a given entity.
+ * Called by bootstrap for every scanned entity.
+ */
+export type OrmFactory = (entity: SchemaLike, name: string) => EntityOrm;
+/**
+ * Container key of an entity's storage — 'reading' → 'ReadingOrm'.
+ *
+ * The twin of {@link repositoryKeyOf} and of `facadeKeyOf`: the key of a thing
+ * lives with the thing. This one was spelled by hand in four places in
+ * `bootstrap.ts` and a fifth in `scanner.ts` — where the SCAN derives what a
+ * constructor asks for. Two readers of one convention, neither of them naming it,
+ * so a rename would have moved one and left the other resolving to nothing.
+ */
+export declare function ormKeyOf(entity: string): string;
+//# sourceMappingURL=orm.d.ts.map

package/dist/orm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.d.ts","sourceRoot":"","sources":["../src/orm.ts"],"names":[],"mappings":"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"}

package/dist/orm.js

@@ -0,0 +1,33 @@
+/**
+ * The keys `list()` answers to. Anything else is a mistake, and saying so is the point:
+ * the façade refuses an unknown key in a CLIENT's input (`Unknown field`) — this applies the
+ * same rule to the framework's own arguments. `list({ orderId })` used to be accepted and
+ * the filter dropped, so a one-to-many relation quietly returned the whole table.
+ */
+export const LIST_OPTION_KEYS = [
+    'limit', 'offset', 'page', 'after', 'orderBy', 'order', 'count', 'where', 'select',
+];
+/** Refuse an option the port does not answer to, naming it and what was expected. */
+export function assertListOptions(options, entity) {
+    if (!options)
+        return;
+    const legal = new Set(LIST_OPTION_KEYS);
+    const strangers = Object.keys(options).filter((key) => !legal.has(key));
+    if (strangers.length === 0)
+        return;
+    throw new Error(`${entity}.list(): unknown option ${strangers.map((s) => `\`${s}\``).join(', ')}. ` +
+        `Known options are ${LIST_OPTION_KEYS.join(', ')} — to filter, pass \`where: { ${strangers[0]}: … }\`.`);
+}
+/**
+ * Container key of an entity's storage — 'reading' → 'ReadingOrm'.
+ *
+ * The twin of {@link repositoryKeyOf} and of `facadeKeyOf`: the key of a thing
+ * lives with the thing. This one was spelled by hand in four places in
+ * `bootstrap.ts` and a fifth in `scanner.ts` — where the SCAN derives what a
+ * constructor asks for. Two readers of one convention, neither of them naming it,
+ * so a rename would have moved one and left the other resolving to nothing.
+ */
+export function ormKeyOf(entity) {
+    return `${entity[0].toUpperCase()}${entity.slice(1)}Orm`;
+}
+//# sourceMappingURL=orm.js.map

package/dist/orm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.js","sourceRoot":"","sources":["../src/orm.ts"],"names":[],"mappings":"AA2CA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ;CAC1E,CAAC;AAEX,qFAAqF;AACrF,MAAM,UAAU,iBAAiB,CAAC,OAA2B,EAAE,MAAc;IAC3E,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAS,gBAAgB,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACxE,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACnC,MAAM,IAAI,KAAK,CACb,GAAG,MAAM,2BAA2B,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;QACnF,qBAAqB,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,iCAAiC,SAAS,CAAC,CAAC,CAAC,UAAU,CACxG,CAAC;AACJ,CAAC;AAgDD;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAc;IACrC,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;AAC3D,CAAC"}

package/dist/presenter.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Presenter(Entity) — enriches an entity's output with computed fields.
+ *
+ * Each method on the presenter is a computed field resolver:
+ * - Receives the entity record as first argument
+ * - Can be sync or async
+ * - Injected via DI (constructor params resolved by the container)
+ *
+ * Usage:
+ * ```ts
+ * export default class PostPresenter extends Presenter(Post) {
+ *   constructor(private commentOrm: CommentOrm) { super(); }
+ *
+ *   excerpt(post: Post) {
+ *     return post.body.slice(0, 200);
+ *   }
+ *
+ *   async commentCount(post: Post) {
+ *     return this.commentOrm.countFor(post.id);
+ *   }
+ * }
+ * ```
+ */
+type EntityClass = abstract new (...args: any[]) => any;
+declare const PRESENTER_TARGET: unique symbol;
+declare const PRESENTER_VIEWS: unique symbol;
+/**
+ * The view a computed field emits — `OrderItemView` for one, `[OrderItemView]` for many.
+ * A view is a schema, so it derives: `Order.pick('id', 'status')`, never a hand-written type.
+ */
+export type PresenterViews = Record<string, EntityClass | [EntityClass]>;
+/**
+ * `Presenter(Order, { items: [OrderItemView], user: UserCard })` — the second argument names
+ * the view each computed field emits, exactly as `Crud(Post, { list: PostCard })` names an
+ * op's. What fabricates a field declares its contract, and it declares it **once**: the
+ * façade applies the presenter (see `egress.ts`), and every surface reads the same statement
+ * instead of guessing.
+ *
+ * Guessing was the cost of not stating it. The scan can read a scalar off a return type and
+ * nothing more, so a field returning an object had no derivable shape: the GraphQL projection
+ * fell back to a serialized `String`, and a client asking `items { quantity }` got a schema
+ * error on a field REST served whole. Declaring is optional — a scalar field needs nothing,
+ * and an undeclared object keeps the old behaviour.
+ */
+export declare function Presenter<E extends EntityClass>(entity: E, views?: PresenterViews): {
+    new (): {};
+    [PRESENTER_TARGET]: E;
+    [PRESENTER_VIEWS]: PresenterViews | undefined;
+};
+/** Get the entity class a presenter targets. */
+export declare function getPresenterTarget(ctor: Function): EntityClass | undefined;
+/**
+ * The views a presenter declares, walked up the prototype chain so a subclass of a
+ * presenter keeps what its base stated. Runtime, like `Crud.__ops`: an installed app whose
+ * source the scan cannot read still carries its contract.
+ */
+export declare function getPresenterViews(ctor: Function): PresenterViews | undefined;
+/** List computed field names from a presenter class (own methods minus constructor). */
+export declare function getPresenterFields(ctor: Function): string[];
+/** Container key of an entity's presenter — 'post' → 'PostPresenter'. */
+export declare function presenterKeyOf(entity: string): string;
+export {};
+//# sourceMappingURL=presenter.d.ts.map

package/dist/presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presenter.d.ts","sourceRoot":"","sources":["../src/presenter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,KAAK,WAAW,GAAG,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAExD,QAAA,MAAM,gBAAgB,eAAyC,CAAC;AAChE,QAAA,MAAM,eAAe,eAAwC,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;AAEzE;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,cAAc;;;;EAMjF;AAED,gDAAgD;AAChD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,GAAG,SAAS,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,GAAG,SAAS,CAM5E;AAED,wFAAwF;AACxF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAG3D;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/presenter.js

@@ -0,0 +1,72 @@
+/**
+ * Presenter(Entity) — enriches an entity's output with computed fields.
+ *
+ * Each method on the presenter is a computed field resolver:
+ * - Receives the entity record as first argument
+ * - Can be sync or async
+ * - Injected via DI (constructor params resolved by the container)
+ *
+ * Usage:
+ * ```ts
+ * export default class PostPresenter extends Presenter(Post) {
+ *   constructor(private commentOrm: CommentOrm) { super(); }
+ *
+ *   excerpt(post: Post) {
+ *     return post.body.slice(0, 200);
+ *   }
+ *
+ *   async commentCount(post: Post) {
+ *     return this.commentOrm.countFor(post.id);
+ *   }
+ * }
+ * ```
+ */
+const PRESENTER_TARGET = Symbol.for('fougere:presenter_target');
+const PRESENTER_VIEWS = Symbol.for('fougere:presenter_views');
+/**
+ * `Presenter(Order, { items: [OrderItemView], user: UserCard })` — the second argument names
+ * the view each computed field emits, exactly as `Crud(Post, { list: PostCard })` names an
+ * op's. What fabricates a field declares its contract, and it declares it **once**: the
+ * façade applies the presenter (see `egress.ts`), and every surface reads the same statement
+ * instead of guessing.
+ *
+ * Guessing was the cost of not stating it. The scan can read a scalar off a return type and
+ * nothing more, so a field returning an object had no derivable shape: the GraphQL projection
+ * fell back to a serialized `String`, and a client asking `items { quantity }` got a schema
+ * error on a field REST served whole. Declaring is optional — a scalar field needs nothing,
+ * and an undeclared object keeps the old behaviour.
+ */
+export function Presenter(entity, views) {
+    class PresenterBase {
+        static [PRESENTER_TARGET] = entity;
+        static [PRESENTER_VIEWS] = views;
+    }
+    return PresenterBase;
+}
+/** Get the entity class a presenter targets. */
+export function getPresenterTarget(ctor) {
+    return ctor[PRESENTER_TARGET];
+}
+/**
+ * The views a presenter declares, walked up the prototype chain so a subclass of a
+ * presenter keeps what its base stated. Runtime, like `Crud.__ops`: an installed app whose
+ * source the scan cannot read still carries its contract.
+ */
+export function getPresenterViews(ctor) {
+    for (let cur = ctor; cur; cur = Object.getPrototypeOf(cur)) {
+        const views = cur[PRESENTER_VIEWS];
+        if (views)
+            return views;
+    }
+    return undefined;
+}
+/** List computed field names from a presenter class (own methods minus constructor). */
+export function getPresenterFields(ctor) {
+    return Object.getOwnPropertyNames(ctor.prototype)
+        .filter((name) => name !== 'constructor' && typeof ctor.prototype[name] === 'function');
+}
+/** Container key of an entity's presenter — 'post' → 'PostPresenter'. */
+export function presenterKeyOf(entity) {
+    return `${entity[0].toUpperCase()}${entity.slice(1)}Presenter`;
+}
+//# sourceMappingURL=presenter.js.map

package/dist/presenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presenter.js","sourceRoot":"","sources":["../src/presenter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAChE,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;AAQ9D;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CAAwB,MAAS,EAAE,KAAsB;IAChF,MAAM,aAAa;QACjB,MAAM,CAAC,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC;QACnC,MAAM,CAAC,CAAC,eAAe,CAAC,GAAG,KAAK,CAAC;;IAEnC,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,gDAAgD;AAChD,MAAM,UAAU,kBAAkB,CAAC,IAAc;IAC/C,OAAQ,IAAY,CAAC,gBAAgB,CAAC,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAc;IAC9C,KAAK,IAAI,GAAG,GAAQ,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;QAChE,MAAM,KAAK,GAAG,GAAG,CAAC,eAAe,CAAC,CAAC;QACnC,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC;IAC1B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,kBAAkB,CAAC,IAAc;IAC/C,OAAO,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC;SAC9C,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,aAAa,IAAI,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,CAAC;AAC5F,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC;AACjE,CAAC"}

package/dist/remote.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Remote façade — what resolve() falls back to.
+ *
+ * When a handler isn't hosted locally and remotes are declared, resolve()
+ * returns a façade-shaped stand-in: same call surface as a local facade,
+ * every operation executed through a Transport. Routing is lazy — on the
+ * first miss, each declared remote is asked what it hosts (rpc.discover)
+ * and the answer is cached. A remote that can't be reached stays pending
+ * and is retried on the next miss instead of being cached as absent.
+ */
+import type { Transport } from './call.js';
+import { type InvocationContext } from './invocation.js';
+import { type SchemaConstructor, type Fields } from '@fougere/schema';
+interface Route {
+    frond: string;
+    transport: Transport;
+    /**
+     * The entity's schema, rebuilt from the identity card — the same
+     * `SchemaConstructor` shape `entity({...})` produces, live validation
+     * included. Reconstructed once per entity, at discovery time.
+     *
+     * **Absent when the door stores nothing.** A handler may carry no entity, so the card
+     * publishes it with ops and no shape; there is nothing to rebuild and pretending
+     * otherwise would hand callers an empty schema that validates everything.
+     */
+    schema?: SchemaConstructor<Fields>;
+}
+export interface RemoteRouter {
+    route(entity: string): Promise<Route>;
+}
+export declare function createRemoteRouter(remotes: Record<string, string>, makeTransport: (url: string) => Transport): RemoteRouter;
+type Facade = Record<string, (invocation?: InvocationContext) => Promise<unknown>>;
+/**
+ * Façade-shaped stand-in — the consumer can't tell it from a local facade.
+ *
+ * Every trap answers the same question, and that is the point: the runner asks
+ * `Object.hasOwn(facade, op)` before calling, so a proxy that only trapped `get`
+ * reported *no* operations and every split call came back `Unknown operation` —
+ * `get` said yes, `hasOwn` said no, and the runner believed `hasOwn`.
+ *
+ * The stand-in claims every legal op name because it cannot know better: routing is
+ * lazy on purpose (the card is fetched at the first miss), and the remote is the
+ * authority on its own surface anyway. An op it does not serve comes back as its
+ * NOT_FOUND — judged where it is owned, which is the same answer a local façade gives.
+ */
+export declare function createRemoteFacade(entity: string, router: RemoteRouter): Facade;
+export {};
+//# sourceMappingURL=remote.d.ts.map

package/dist/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAA2B,SAAS,EAAE,MAAM,WAAW,CAAC;AAEpE,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE3E,OAAO,EAAe,KAAK,iBAAiB,EAAE,KAAK,MAAM,EAAyB,MAAM,iBAAiB,CAAC;AAE1G,UAAU,KAAK;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,SAAS,CAAC;IACrB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CACvC;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,SAAS,GACxC,YAAY,CA+Fd;AAED,KAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;AAWnF;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAiB/E"}

package/dist/remote.js

@@ -0,0 +1,135 @@
+import { RPC_ENTITY } from './call.js';
+import { EMPTY_INVOCATION } from './invocation.js';
+import { FougereError, ErrorCode } from './middleware.js';
+import { reconstruct } from '@fougere/schema';
+export function createRemoteRouter(remotes, makeTransport) {
+    const byEntity = new Map();
+    // The remotes config key is a label for the address — the identity card is
+    // what decides which entities live behind it.
+    const pending = new Map(Object.entries(remotes));
+    const transports = new Map();
+    /** Which remote label claimed a door name — so a second claim can name the first. */
+    const claimedBy = new Map();
+    const discover = async () => {
+        // Asking is concurrent; INDEXING is not, and is done in the order `remotes` declares.
+        // Reading the cards inside the race made "which remote won" depend on who answered
+        // first, so the same two remotes could resolve differently between two runs.
+        const cards = await Promise.all([...pending].map(async ([label, url]) => {
+            const transport = transports.get(url) ?? makeTransport(url);
+            transports.set(url, transport);
+            try {
+                const card = (await transport({ entity: RPC_ENTITY, op: 'discover' }, EMPTY_INVOCATION));
+                return { label, transport, card };
+            }
+            catch {
+                // Unreachable — stays pending, retried on the next miss.
+                return undefined;
+            }
+        }));
+        for (const answered of cards) {
+            if (!answered)
+                continue;
+            const { label, transport, card } = answered;
+            pending.delete(label);
+            for (const frond of card.fronds) {
+                // Doors only. A fact is not routable — nobody calls it, it arrives — so
+                // adding one here would answer a call with a transport to a door that
+                // does not exist.
+                for (const door of frond.doors) {
+                    const held = claimedBy.get(door.name);
+                    /**
+                     * Two remotes claiming one name is refused, not silently arbitrated.
+                     *
+                     * `byEntity` is keyed by the door name alone, so the second claim used to be
+                     * dropped with `if (!byEntity.has(...))` — no warning, and the winner was
+                     * whichever remote answered first. The local boot already refuses the same
+                     * collision (`assertOneOwnerPerKey`) and it refused the OTHER duplicate: in
+                     * process the last frond loaded won, here the first discovered did. One
+                     * application, two topologies, two different handlers answering — which is
+                     * precisely the gradient not holding.
+                     *
+                     * Refusing is the honest answer while a call names an entity and not a frond.
+                     * `FrondCall` already carries an optional `frond`; the day it is required, this
+                     * becomes a disambiguation instead of a refusal.
+                     */
+                    if (held !== undefined && held !== label) {
+                        throw new FougereError({
+                            code: ErrorCode.INTERNAL_ERROR,
+                            message: `Two remotes serve '${door.name}': '${held}' and '${label}'.\n`
+                                + `  A call names an entity, not a frond, so nothing could choose between them.\n`
+                                + `  - Keep one of the two out of \`remotes:\`, or\n`
+                                + `  - expose one of them under a different entity name.`,
+                            entity: door.name,
+                        });
+                    }
+                    claimedBy.set(door.name, label);
+                    byEntity.set(door.name, {
+                        frond: frond.name,
+                        transport,
+                        ...(door.schema ? { schema: reconstruct(door.schema) } : {}),
+                    });
+                }
+            }
+        }
+    };
+    return {
+        async route(entity) {
+            if (!byEntity.has(entity) && pending.size > 0)
+                await discover();
+            const hit = byEntity.get(entity);
+            if (hit)
+                return hit;
+            if (pending.size > 0) {
+                throw new FougereError({
+                    code: ErrorCode.SERVICE_UNAVAILABLE,
+                    message: `No reachable remote hosts '${entity}' — unreachable: ${[...pending.keys()].join(', ')}`,
+                    entity,
+                });
+            }
+            throw new FougereError({
+                code: ErrorCode.NOT_FOUND,
+                message: `No declared remote hosts '${entity}'`,
+                entity,
+            });
+        },
+    };
+}
+/**
+ * Does this name designate an operation at all? `then` is excluded so the façade is
+ * never mistaken for a thenable, and `Object.prototype`'s own names so `constructor`
+ * or `toString` cannot be called across the wire.
+ */
+function isOpName(prop) {
+    return typeof prop === 'string' && prop !== 'then' && !Object.hasOwn(Object.prototype, prop);
+}
+/**
+ * Façade-shaped stand-in — the consumer can't tell it from a local facade.
+ *
+ * Every trap answers the same question, and that is the point: the runner asks
+ * `Object.hasOwn(facade, op)` before calling, so a proxy that only trapped `get`
+ * reported *no* operations and every split call came back `Unknown operation` —
+ * `get` said yes, `hasOwn` said no, and the runner believed `hasOwn`.
+ *
+ * The stand-in claims every legal op name because it cannot know better: routing is
+ * lazy on purpose (the card is fetched at the first miss), and the remote is the
+ * authority on its own surface anyway. An op it does not serve comes back as its
+ * NOT_FOUND — judged where it is owned, which is the same answer a local façade gives.
+ */
+export function createRemoteFacade(entity, router) {
+    const opFn = (op) => async (invocation = EMPTY_INVOCATION) => {
+        const { frond, transport } = await router.route(entity);
+        const call = { frond, entity, op };
+        return transport(call, invocation);
+    };
+    return new Proxy({}, {
+        get: (_target, prop) => (isOpName(prop) ? opFn(prop) : undefined),
+        has: (_target, prop) => isOpName(prop),
+        getOwnPropertyDescriptor: (_target, prop) => 
+        // `configurable: true` is required: a proxy may not report a non-configurable
+        // property that the target does not actually have.
+        isOpName(prop)
+            ? { value: opFn(prop), writable: false, enumerable: true, configurable: true }
+            : undefined,
+    });
+}
+//# sourceMappingURL=remote.js.map

package/dist/remote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.js","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"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"}

package/dist/repository.d.ts

@@ -0,0 +1,55 @@
+import type { EntityOrm } from './orm.js';
+/**
+ * Repository(Entity) — where an entity's reads and writes are named.
+ *
+ * `EntityOrm` is a port: five generic gestures, no flavour of domain. "The readings
+ * of the last hour" is not one of them, so it used to be spelled at the call site —
+ * `orm.list({ orderBy: 'at', order: 'desc', limit: 4096 })` followed by a filter in
+ * JavaScript, sitting in the middle of the calculation it feeds. A query with no home
+ * squats in the answer.
+ *
+ * So the port gains a place to be extended, per entity:
+ *
+ * ```ts
+ * // repositories/ReadingRepository.ts
+ * export default class ReadingRepository extends Repository(Reading) {
+ *   since(moment: Date) {
+ *     return this.orm.list({ where: { at: { gte: moment } } });
+ *   }
+ * }
+ * ```
+ *
+ * A handler then asks the question and never spells the storage:
+ *
+ * ```ts
+ * async hourly() {
+ *   return average(await this.readings.since(anHourAgo()));
+ * }
+ * ```
+ *
+ * **Write none and you lose nothing.** The bootstrap registers a default repository
+ * for every entity — the guarded ORM itself — so `ReadingRepository` resolves whether
+ * or not the file exists. Declaring one wins, exactly as a `Crud` op redefined in the
+ * subclass wins over the prefab. Convention, not configuration.
+ *
+ * It is NOT a door: a repository has no façade, so nothing here is reachable from the
+ * wire. A judge still lives in the handler, which is the only place a refusal cannot
+ * be walked around.
+ */
+type EntityClass = abstract new (...args: any[]) => any;
+/** What a repository is handed, and what it exposes to whoever holds it. */
+export interface RepositoryOf<T> {
+    /** The entity's port, already guarded — a value the shape forbids is refused here too. */
+    orm: EntityOrm<T>;
+}
+export interface RepositoryConstructor<T> {
+    new (orm: EntityOrm<T>): RepositoryOf<T>;
+    readonly __entity: unknown;
+}
+export declare function Repository<E extends EntityClass>(entity: E): RepositoryConstructor<InstanceType<E>>;
+/** Get the entity class a repository targets. */
+export declare function getRepositoryTarget(ctor: Function): EntityClass | undefined;
+/** Container key of an entity's repository — 'reading' → 'ReadingRepository'. */
+export declare function repositoryKeyOf(entity: string): string;
+export {};
+//# sourceMappingURL=repository.d.ts.map

package/dist/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../src/repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,KAAK,WAAW,GAAG,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAIxD,4EAA4E;AAC5E,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,0FAA0F;IAC1F,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC,KAAK,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,WAAW,EAAE,MAAM,EAAE,CAAC,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAWnG;AAED,iDAAiD;AACjD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,GAAG,SAAS,CAO3E;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/repository.js

@@ -0,0 +1,26 @@
+const REPOSITORY_TARGET = Symbol.for('fougere:repository_target');
+export function Repository(entity) {
+    class RepositoryBase {
+        orm;
+        static [REPOSITORY_TARGET] = entity;
+        static __entity = entity;
+        constructor(orm) {
+            this.orm = orm;
+        }
+    }
+    return RepositoryBase;
+}
+/** Get the entity class a repository targets. */
+export function getRepositoryTarget(ctor) {
+    for (let cur = ctor; cur; cur = Object.getPrototypeOf(cur)) {
+        const target = cur[REPOSITORY_TARGET];
+        if (target)
+            return target;
+    }
+    return undefined;
+}
+/** Container key of an entity's repository — 'reading' → 'ReadingRepository'. */
+export function repositoryKeyOf(entity) {
+    return `${entity[0].toUpperCase()}${entity.slice(1)}Repository`;
+}
+//# sourceMappingURL=repository.js.map

package/dist/repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.js","sourceRoot":"","sources":["../src/repository.ts"],"names":[],"mappings":"AA0CA,MAAM,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAC;AAalE,MAAM,UAAU,UAAU,CAAwB,MAAS;IAGzD,MAAM,cAAc;QAIC;QAHnB,MAAM,CAAC,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC;QACpC,MAAM,CAAU,QAAQ,GAAG,MAAM,CAAC;QAElC,YAAmB,GAAiB;YAAjB,QAAG,GAAH,GAAG,CAAc;QAAG,CAAC;;IAG1C,OAAO,cAAqD,CAAC;AAC/D,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,mBAAmB,CAAC,IAAc;IAChD,KAAK,IAAI,GAAG,GAAQ,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;QAChE,MAAM,MAAM,GAAG,GAAG,CAAC,iBAAiB,CAAC,CAAC;QACtC,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC;IAC5B,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,eAAe,CAAC,MAAc;IAC5C,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC;AAClE,CAAC"}

package/dist/scan-cache.d.ts

@@ -0,0 +1,10 @@
+export declare function setCacheRoot(dir: string): void;
+export declare function hashFile(filePath: string): string;
+/** Get cached parse result. Returns null if cache miss. */
+export declare function getCached<T>(key: string, hash: string): T | null;
+/** Store parse result in cache. */
+export declare function setCached(key: string, hash: string, data: unknown): void;
+export { getCached as getCachedMethods, setCached as setCachedMethods };
+/** Write cache to disk if modified. */
+export declare function flushCache(): void;
+//# sourceMappingURL=scan-cache.d.ts.map

package/dist/scan-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-cache.d.ts","sourceRoot":"","sources":["../src/scan-cache.ts"],"names":[],"mappings":"AAoDA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAG9C;AAsBD,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED,2DAA2D;AAC3D,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAKhE;AAED,mCAAmC;AACnC,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAIxE;AAGD,OAAO,EAAE,SAAS,IAAI,gBAAgB,EAAE,SAAS,IAAI,gBAAgB,EAAE,CAAC;AAExE,uCAAuC;AACvC,wBAAgB,UAAU,IAAI,IAAI,CAOjC"}