@fougere/core 0.1.0-alpha.0

package/dist/egress.js

@@ -0,0 +1,185 @@
+/**
+ * A value leaving the domain.
+ *
+ * Two things happen every time, in this order:
+ *
+ *   1. JUDGE — is this a legal value? Read from `shape` alone, so the answer does not
+ *      depend on who is receiving. It has to come first: judging after the projection
+ *      would fail on a client view that legitimately dropped its `writeOnly` fields.
+ *   2. PROJECT — what may THIS receiver see? A client does not get a password hash;
+ *      storage sees everything.
+ *
+ * Storage is a way out like the others. It used to be the exception — the ORM wrote
+ * whatever a handler handed it, so `status: 'n-importe-quoi'` on a
+ * `oneOf('draft','published')` was stored and read back unchanged (measured
+ * 2026-07-25). The database is a weak judge: it catches nullability and, outside
+ * SQLite, the column type — never a closed set, a format or a range, since the DDL
+ * emits no CHECK. The choice was never "fail late or judge early", it was "corrupt
+ * silently or judge early".
+ *
+ * What the judge must NOT read: `boundary` and `lifecycle`. Both answer "may a CLIENT
+ * send this?", a question with no meaning when the domain itself is writing — reading
+ * them here is exactly what makes `Post.validate(a_db_row)` come back invalid.
+ *
+ * Shallow, like `encodeFields` it stands on: a relation's nested rows are not reached.
+ * A handler that hand-rolls its own envelope owns its own egress.
+ */
+import { checkValue, encodeFields } from '@fougere/schema';
+import { ErrorCode, FougereError } from './middleware.js';
+import { assertListOptions } from './orm.js';
+// ─── 1 · Judge ──────────────────────────────────────────────
+/**
+ * Refuse a value the shape does not accept, before it goes anywhere.
+ *
+ * Only the keys actually present are judged, so a patch stays a patch: an update
+ * naming one field says nothing about the others. A key with no field is not this
+ * judge's business — the receiver fails on its own (an unknown column), and a client
+ * input already met `validateFields`, which refuses strangers.
+ */
+export function judgeEgress(fields, value, entity, operation) {
+    if (typeof value !== 'object' || value === null)
+        return;
+    const errors = [];
+    for (const [key, item] of Object.entries(value)) {
+        const field = fields[key];
+        if (!field || item === undefined)
+            continue;
+        const checked = checkValue(field, item);
+        if ('error' in checked)
+            errors.push(`${key}: ${checked.error}`);
+    }
+    if (errors.length === 0)
+        return;
+    // The domain produced this, not a caller — so it is our bug, not a bad request,
+    // and no retry with different input can fix it.
+    throw new FougereError({
+        code: ErrorCode.INTERNAL_ERROR,
+        message: `Refused on the way out — ${errors.join(', ')}`,
+        entity,
+        operation,
+        details: errors,
+    });
+}
+// ─── 2 · Project ────────────────────────────────────────────
+/**
+ * An array's own non-index properties. `ListResult` IS an array — it carries
+ * `hasMore`/`endCursor`/`total` on itself rather than wrapping the rows — so
+ * mapping over it must not drop them.
+ */
+function arrayExtras(source) {
+    const extras = {};
+    for (const key of Object.keys(source)) {
+        if (!/^\d+$/.test(key))
+            extras[key] = source[key];
+    }
+    return extras;
+}
+/**
+ * Drop what this receiver may not see — a `writeOnly` field goes here — then hand the
+ * rest to `encodeFields`, which converts the values to their wire form.
+ *
+ * `closed` says the field set is the WHOLE of what this op emits, so anything else is
+ * dropped. That is what naming a view for an op means (`Crud(Post, { list: PostCard })`):
+ * the author states the audience, and a field they left out must not ride along. Open is
+ * the default and stays the rule for the entity itself — a presenter's computed field is
+ * an addition to the entity's output, not an intruder.
+ */
+export function projectEgress(fields, result, closed = false) {
+    if (result === null || result === undefined)
+        return result;
+    if (Array.isArray(result)) {
+        const rows = result.map((item) => projectEgress(fields, item, closed));
+        return Object.assign(rows, arrayExtras(result));
+    }
+    // A scalar (the boolean from `delete`, an id) crosses untouched.
+    if (typeof result !== 'object')
+        return result;
+    const record = result;
+    const scoped = closed
+        ? Object.fromEntries(Object.keys(fields).filter((k) => k in record).map((k) => [k, record[k]]))
+        : record;
+    return encodeFields(fields, scoped);
+}
+export async function presentEgress(result, presenter, fieldNames, entity = 'unknown', operation = 'unknown', args = {}) {
+    if (!presenter || !fieldNames?.length || result === null || typeof result !== 'object')
+        return result;
+    const rows = Array.isArray(result) ? result : [result];
+    const values = new Map();
+    // One pass per FIELD over every row, not one pass per row over every field. A
+    // computed field that reads issues its query once for the page — which is the
+    // whole reason it is handed the page. And the reader arrives here as an argument,
+    // bound from the signature like a handler's, so a field may depend on who asks.
+    for (const name of fieldNames) {
+        const fn = presenter[name];
+        if (typeof fn !== 'function')
+            continue;
+        try {
+            const answered = await fn.call(presenter, rows, ...(args[name] ?? []));
+            if (!Array.isArray(answered) || answered.length !== rows.length) {
+                throw new Error(`expected ${rows.length} value(s) for ${rows.length} row(s), got ${Array.isArray(answered) ? answered.length : typeof answered}`);
+            }
+            values.set(name, answered);
+        }
+        catch (cause) {
+            // A throwing computed field would take the whole operation down with a raw
+            // stack. Name the field instead: the domain produced this, so it is our bug —
+            // same verdict `judgeEgress` renders.
+            throw new FougereError({
+                code: ErrorCode.INTERNAL_ERROR,
+                message: `Computed field '${name}' failed: ${cause?.message ?? cause}`,
+                entity,
+                operation,
+                cause,
+            });
+        }
+    }
+    const enriched = rows.map((item, index) => {
+        if (item === null || typeof item !== 'object')
+            return item;
+        const out = { ...item };
+        for (const [name, answered] of values)
+            out[name] = answered[index];
+        return out;
+    });
+    // `ListResult` IS an array — carry its own properties across, like projectEgress.
+    return Array.isArray(result) ? Object.assign(enriched, arrayExtras(result)) : enriched[0];
+}
+/**
+ * The storage way out: judge, then hand over. There is no projection step — storage is
+ * the receiver that sees everything, which is precisely why a `writeOnly` field can be
+ * persisted while never reaching a browser.
+ *
+ * `Object.create` keeps the original on the prototype chain, so reads, `output()` and
+ * whatever else an adapter carries still resolve, and a copy scoped later inherits the
+ * judgement instead of escaping it.
+ */
+export function guardStorage(orm, fields, entityName) {
+    const base = orm;
+    if (typeof base.create !== 'function' || typeof base.update !== 'function')
+        return orm;
+    const guarded = Object.create(orm);
+    // `async` on purpose: a refusal must REJECT the promise, not throw synchronously —
+    // a sync throw from an awaited call skips every `.catch` the caller wrote.
+    // Rest arguments, forwarded verbatim: an ORM must see the arity its caller used.
+    guarded.create = async function (...args) {
+        judgeEgress(fields, args[0], entityName, 'create');
+        return base.create.apply(this, args);
+    };
+    guarded.update = async function (...args) {
+        judgeEgress(fields, args[1], entityName, 'update');
+        return base.update.apply(this, args);
+    };
+    // A read is judged too, on its ARGUMENTS. The façade refuses an unknown key in a client's
+    // input; the same rule applied to the port's own options closes the mirror image of that
+    // hole: `list({ orderId })` was accepted, the criterion dropped, and a one-to-many relation
+    // quietly answered with the whole table. An option nobody reads must say so.
+    const reader = orm;
+    if (typeof reader.list === 'function') {
+        guarded.list = async function (...args) {
+            assertListOptions(args[0], entityName);
+            return reader.list.apply(this, args);
+        };
+    }
+    return guarded;
+}
+//# sourceMappingURL=egress.js.map

package/dist/egress.js.map

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

package/dist/emit.d.ts

@@ -0,0 +1,51 @@
+/**
+ * What an emitter injects. Resolved by type, like `EntityOrm<Post>` and `Facade<T>`.
+ *
+ * The returned promise settles when the fact has been **dispatched**, never when it has
+ * been handled: a subscriber's failure is its own. The `EventBus` this replaces did
+ * `await Promise.all(handlers)` and handed their rejections back, which made a publication
+ * hostage to its own indexer.
+ */
+export type Emit<T> = (fact: T) => Promise<void>;
+/**
+ * What a subscriber accepts — and what it PROMISES about itself.
+ *
+ * Not merely "I subscribe". Push is the strict mode and pull is a special case of it: an
+ * op written for push is correct when called directly, the reverse is false. So this
+ * wrapper commits the operation to three things its author must honour, because no type
+ * can check them:
+ *
+ * 1. **replayable** — delivery is at-least-once the day a broker sits underneath;
+ * 2. **no reader for its return** — nobody receives what it hands back;
+ * 3. **owner of its failures** — they reach a log, never the emitter.
+ *
+ * It is the identity at runtime. The scan reads the written name, which is the whole
+ * mechanism: `binding.ts` sees `Fact<X>` and binds the parameter as a fact instead of
+ * letting it fall through to "everything else — body".
+ */
+export type Fact<T> = T;
+/**
+ * The container key of an emission — THE one place that spells the format.
+ *
+ * Its dual is right below, because the boot reads the fact back out of a handler's `deps`
+ * to know which emissions to register. A key and the way to undo it belong together: the
+ * pair that is split is the pair that drifts.
+ */
+export declare function emitKeyOf(fact: string): string;
+/** The fact behind an emission key, or `undefined` when the key is not one. */
+export declare function factOfEmitKey(key: string): string | undefined;
+/**
+ * What a set of handlers ANNOUNCES — `Emit<T>` read back out of their dependencies.
+ *
+ * Two readers, which is exactly why it is a function and not a line: the boot registers one
+ * emission value per name, and the identity card publishes the same set. Spelled twice they
+ * would drift the day an emission stops being a constructor dependency.
+ *
+ * The dual — what a handler ACCEPTS — is not here, because it is not read the same way: a
+ * `Fact<T>` parameter is a fact about one operation, and `computeBindingPlan` has already
+ * written it into the plan (`app.listensTo()`).
+ */
+export declare function factsAnnouncedBy(handlers: ReadonlyArray<{
+    deps: readonly string[];
+}>): string[];
+//# sourceMappingURL=emit.d.ts.map

package/dist/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAuBA;;;;;;;GAOG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AAExB;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAID,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,GAAG,MAAM,EAAE,CAO/F"}

package/dist/emit.js

@@ -0,0 +1,57 @@
+/**
+ * Announcing a fact — the half of the topology `remotes:` never covered.
+ *
+ * Every other call in Fougere names **one** recipient: `remotes` names one address per
+ * frond, `Facade<T>` resolves one door. `Emit<T>` names a **subject** instead, and the
+ * number of readers is not the emitter's business.
+ *
+ * ```ts
+ * constructor(private published: Emit<PostPublished>) {}
+ * await this.published({ id, title });          // I say it happened. I do not know who cares.
+ *
+ * async reindex(fact: Fact<PostPublished>) {}   // any handler, any frond. Nothing to register.
+ * ```
+ *
+ * **It is a resolver, not a channel.** A bus moves messages — it has a queue, an envelope
+ * format, a delivery semantic. This has none of that: it answers *who*, then hands over to
+ * the call path that already exists. It is `resolve` returning N things instead of one.
+ * That is also why temporal decoupling stays out of reach: a resolver holds nothing. The
+ * day at-least-once is wanted, a real channel goes UNDER this, in the transport — the
+ * dispatch line becomes a publish and a consumer calls the same door on the far side.
+ */
+import { toRegistrationName } from './contract.js';
+/**
+ * The container key of an emission — THE one place that spells the format.
+ *
+ * Its dual is right below, because the boot reads the fact back out of a handler's `deps`
+ * to know which emissions to register. A key and the way to undo it belong together: the
+ * pair that is split is the pair that drifts.
+ */
+export function emitKeyOf(fact) {
+    return `${toRegistrationName(fact)}Emit`;
+}
+const SUFFIX = 'Emit';
+/** The fact behind an emission key, or `undefined` when the key is not one. */
+export function factOfEmitKey(key) {
+    return key.length > SUFFIX.length && key.endsWith(SUFFIX)
+        ? key.slice(0, -SUFFIX.length)
+        : undefined;
+}
+/**
+ * What a set of handlers ANNOUNCES — `Emit<T>` read back out of their dependencies.
+ *
+ * Two readers, which is exactly why it is a function and not a line: the boot registers one
+ * emission value per name, and the identity card publishes the same set. Spelled twice they
+ * would drift the day an emission stops being a constructor dependency.
+ *
+ * The dual — what a handler ACCEPTS — is not here, because it is not read the same way: a
+ * `Fact<T>` parameter is a fact about one operation, and `computeBindingPlan` has already
+ * written it into the plan (`app.listensTo()`).
+ */
+export function factsAnnouncedBy(handlers) {
+    return [...new Set(handlers
+            .flatMap((handler) => handler.deps)
+            .map(factOfEmitKey)
+            .filter((fact) => fact !== undefined))];
+}
+//# sourceMappingURL=emit.js.map

package/dist/emit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.js","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AA8BnD;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,GAAG,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC;AAC3C,CAAC;AAED,MAAM,MAAM,GAAG,MAAM,CAAC;AAEtB,+EAA+E;AAC/E,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,OAAO,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC;QACvD,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;QAC9B,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAoD;IACnF,OAAO,CAAC,GAAG,IAAI,GAAG,CAChB,QAAQ;aACL,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;aAClC,GAAG,CAAC,aAAa,CAAC;aAClB,MAAM,CAAC,CAAC,IAAI,EAAkB,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CACxD,CAAC,CAAC;AACL,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * HTTP error mapping — used by HTTP bridges (REST, Next, Inertia).
+ *
+ * Not imported by GraphQL, CLI, or event bus bridges.
+ */
+import { FougereError, ErrorCode } from './middleware.js';
+/** Map a FougereError code to its HTTP status. */
+export declare function httpStatusFor(code: ErrorCode): number;
+/**
+ * Serialize an application error for an untrusted caller.
+ *
+ * Every code but INTERNAL_ERROR was written for the caller and travels whole. An
+ * INTERNAL_ERROR is replaced by a constant — and logged here, with its cause, so the
+ * sentence exists exactly once: on the server.
+ */
+export declare function toPublicError(err: FougereError): ReturnType<FougereError['toJSON']>;
+/** Map any thrown error to `{ status, body }` for HTTP bridges. */
+export declare function toHttpError(err: unknown): {
+    status: number;
+    body: ReturnType<FougereError['toJSON']>;
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAkC1D,kDAAkD;AAClD,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAErD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAUnF;AAED,mEAAmE;AACnE,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAA;CAAE,CAYtG"}

package/dist/errors.js

@@ -0,0 +1,74 @@
+/**
+ * HTTP error mapping — used by HTTP bridges (REST, Next, Inertia).
+ *
+ * Not imported by GraphQL, CLI, or event bus bridges.
+ */
+import { FougereError, ErrorCode } from './middleware.js';
+import { Logger } from './builtins/logger.js';
+/**
+ * An INTERNAL_ERROR is the one class of error whose message never leaves: it was not
+ * written for a caller and may quote a path, a query or a row. Masking it is right, and
+ * masking it *silently* is how a bug becomes unobservable — the operator loses the same
+ * sentence the attacker does. So the mask and the record live in one function: whoever
+ * calls `toPublicError` cannot forget the half that keeps the error findable.
+ */
+const log = new Logger('error');
+const HTTP_STATUS = {
+    [ErrorCode.VALIDATION_FAILED]: 400,
+    [ErrorCode.BAD_REQUEST]: 400,
+    [ErrorCode.UNAUTHORIZED]: 401,
+    [ErrorCode.FORBIDDEN]: 403,
+    [ErrorCode.NOT_FOUND]: 404,
+    [ErrorCode.GONE]: 410,
+    [ErrorCode.CONFLICT]: 409,
+    [ErrorCode.LOCKED]: 423,
+    [ErrorCode.METHOD_NOT_ALLOWED]: 405,
+    [ErrorCode.PRECONDITION_FAILED]: 412,
+    [ErrorCode.PAYLOAD_TOO_LARGE]: 413,
+    [ErrorCode.UNPROCESSABLE_ENTITY]: 422,
+    [ErrorCode.TOO_MANY_REQUESTS]: 429,
+    [ErrorCode.REQUEST_TIMEOUT]: 408,
+    [ErrorCode.INTERNAL_ERROR]: 500,
+    [ErrorCode.NOT_IMPLEMENTED]: 501,
+    [ErrorCode.BAD_GATEWAY]: 502,
+    [ErrorCode.SERVICE_UNAVAILABLE]: 503,
+    [ErrorCode.GATEWAY_TIMEOUT]: 504,
+};
+/** Map a FougereError code to its HTTP status. */
+export function httpStatusFor(code) {
+    return HTTP_STATUS[code] ?? 500;
+}
+/**
+ * Serialize an application error for an untrusted caller.
+ *
+ * Every code but INTERNAL_ERROR was written for the caller and travels whole. An
+ * INTERNAL_ERROR is replaced by a constant — and logged here, with its cause, so the
+ * sentence exists exactly once: on the server.
+ */
+export function toPublicError(err) {
+    if (err.code !== ErrorCode.INTERNAL_ERROR)
+        return err.toJSON();
+    const where = [err.entity, err.operation].filter(Boolean).join('.');
+    log.error(`${where || 'internal'}: ${err.message}`, err.cause ?? err);
+    return {
+        code: ErrorCode.INTERNAL_ERROR,
+        message: 'Internal error',
+        ...(err.entity && { entity: err.entity }),
+        ...(err.operation && { operation: err.operation }),
+    };
+}
+/** Map any thrown error to `{ status, body }` for HTTP bridges. */
+export function toHttpError(err) {
+    if (err instanceof FougereError) {
+        return { status: httpStatusFor(err.code), body: toPublicError(err) };
+    }
+    // A throw that never became a FougereError is masked by the same rule, so it goes
+    // through the same door rather than growing a second, quieter one here.
+    const framed = new FougereError({
+        code: ErrorCode.INTERNAL_ERROR,
+        message: err?.message ?? 'Internal error',
+        cause: err,
+    });
+    return { status: 500, body: toPublicError(framed) };
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

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

package/dist/frond-config.d.ts

@@ -0,0 +1,80 @@
+import type { SchemaLike } from '@fougere/schema';
+import type { BindingPlan } from './binding.js';
+/**
+ * Per-operation override. Config takes precedence over conventions (isReadOp, facade lookup).
+ *
+ * Two families of keys, and they act at different depths:
+ *
+ * - **Surface** (`kind`, `handler`, `method`, `policy`) — how the op is EXPOSED. Read by
+ *   the transport adapters: `kind` decides query vs mutation and GET vs POST.
+ * - **Contract** (`input`, `output`, `binding`) — what the op IS. Read by the façade,
+ *   and this is the third producer of an {@link OperationContract}: a prefab DECLARES its
+ *   ops (`Crud.__ops`), the scan DERIVES them from source, config STATES them outright.
+ *   The façade cannot tell the three apart.
+ *
+ * Stating a contract here makes the scan optional rather than load-bearing. Two cases it
+ * answers that nothing else does:
+ * - a method inherited from an **installed** base class — the scan resolves nothing there
+ *   (workspace-only heritage) and says nothing, so the op silently misses the façade;
+ * - a signature the AST parser cannot read (a type alias, `type CurrentUser = User | null`).
+ *
+ * Config wins over both other producers — it is the most explicit statement, made by
+ * whoever assembles the app. Precedence: CLI > frond config > fougere config > scan >
+ * conventions.
+ */
+export interface OperationOverride {
+    /** Force operation kind (overrides isReadOp-based default). */
+    kind?: 'query' | 'command';
+    /**
+     * Handler class to delegate to (overrides the default `{Entity}Handler` lookup).
+     * Class name is used to resolve from DI. E.g. `ArchiveHandler` → `app.resolve('ArchiveHandler')`.
+     */
+    handler?: abstract new (...args: any[]) => any;
+    /** Method name on `handler` (defaults to the operation name). */
+    method?: string;
+    /**
+     * CASL ability check (e.g. 'archive Post'). **Declared, not implemented** — no
+     * reader interprets it today, in any adapter. Kept as the named slot for the
+     * question rather than silently dropped, but do not rely on it: a config that
+     * states a policy is not enforced anywhere.
+     *
+     * Wiring it means adopting a rules engine, which is precisely what the design
+     * turns down: an identity-dependent right is judged INSIDE the operation
+     * (`publish` reads `post.authorId !== user.id`), and a door-dependent one is a
+     * surface. Neither needs a second vocabulary evaluated by a second engine.
+     */
+    policy?: string;
+    /** What judges the input. The view carries its own mode (`partial()` → patch). */
+    input?: SchemaLike;
+    /**
+     * Where each argument is read from — states what the scan would otherwise derive
+     * from the method signature. An empty array is meaningful: "this op takes nothing".
+     */
+    binding?: BindingPlan;
+}
+export interface FrondConfig {
+    /** Class names exposed as the frond's public contract (all surfaces). */
+    expose?: string[];
+    /** Per-surface entity lists. Overrides default deduction for each named surface. */
+    surfaces?: Record<string, string[]>;
+    /** Interface → implementation bindings for DI (e.g. { Database: 'SqliteDatabase' }). */
+    bindings?: Record<string, string>;
+    /** Per-operation overrides. Key = operation name (method name on a handler). */
+    operations?: Record<string, OperationOverride>;
+}
+/**
+ * Define a frond configuration (typed identity helper).
+ *
+ * ```ts
+ * // fronds/auth/frond.config.ts
+ * import { defineFrond } from '@fougere/core'
+ * export default defineFrond({ expose: ['User', 'AuthHandler'] })
+ * ```
+ */
+export declare function defineFrond(config: FrondConfig): FrondConfig;
+/**
+ * Load a frond's `frond.config.{ts,js,mjs}` from the given frond directory.
+ * Returns `undefined` if no config file is found.
+ */
+export declare function loadFrondConfig(frondPath: string): Promise<FrondConfig | undefined>;
+//# sourceMappingURL=frond-config.d.ts.map

package/dist/frond-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frond-config.d.ts","sourceRoot":"","sources":["../src/frond-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B;;;OAGG;IACH,OAAO,CAAC,EAAE,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAC/C,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAIhB,kFAAkF;IAClF,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;CAOvB;AAED,MAAM,WAAW,WAAW;IAC1B,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpC,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CAChD;AAID;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE5D;AAMD;;;GAGG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CASzF"}

package/dist/frond-config.js

@@ -0,0 +1,32 @@
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+// ── Helper ───────────────────────────────────────
+/**
+ * Define a frond configuration (typed identity helper).
+ *
+ * ```ts
+ * // fronds/auth/frond.config.ts
+ * import { defineFrond } from '@fougere/core'
+ * export default defineFrond({ expose: ['User', 'AuthHandler'] })
+ * ```
+ */
+export function defineFrond(config) {
+    return config;
+}
+// ── Loading ──────────────────────────────────────
+const FROND_CONFIG_FILES = ['frond.config.ts', 'frond.config.js', 'frond.config.mjs'];
+/**
+ * Load a frond's `frond.config.{ts,js,mjs}` from the given frond directory.
+ * Returns `undefined` if no config file is found.
+ */
+export async function loadFrondConfig(frondPath) {
+    for (const file of FROND_CONFIG_FILES) {
+        const path = resolve(frondPath, file);
+        if (existsSync(path)) {
+            const mod = await import(path);
+            return mod.default ?? mod;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=frond-config.js.map

package/dist/frond-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frond-config.js","sourceRoot":"","sources":["../src/frond-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AA+ErC,oDAAoD;AAEpD;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,MAAmB;IAC7C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,oDAAoD;AAEpD,MAAM,kBAAkB,GAAG,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;AAEtF;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,SAAiB;IACrD,KAAK,MAAM,IAAI,IAAI,kBAAkB,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACtC,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACrB,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC;YAC/B,OAAO,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC;QAC5B,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/graph.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Entity dependency graph — analyzes ref() links between entities
+ * to suggest domain boundaries for splitting fronds.
+ */
+import type { FrondDescriptor } from './types.js';
+export interface EntityNode {
+    name: string;
+    frond: string;
+    refs: string[];
+    referencedBy: string[];
+}
+export interface DomainCluster {
+    name: string;
+    entities: string[];
+    crossRefs: {
+        from: string;
+        to: string;
+        targetCluster: string;
+    }[];
+}
+/** Build the full entity dependency graph from scanned fronds. */
+export declare function buildGraph(fronds: FrondDescriptor[]): Map<string, EntityNode>;
+/**
+ * Cluster entities into domains using connected component analysis.
+ * Entities linked by refs (in either direction) belong to the same cluster.
+ */
+export declare function clusterEntities(nodes: Map<string, EntityNode>): DomainCluster[];
+/**
+ * If there's only one big cluster, try to split it using Kernighan-Lin-style
+ * heuristic: find the entity with the fewest cross-links and use it as a cut point.
+ */
+export declare function suggestSplit(nodes: Map<string, EntityNode>, minClusterSize?: number): DomainCluster[];
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,YAAY,CAAC;AAE/D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAClE;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CA6B7E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,aAAa,EAAE,CAwC/E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAC9B,cAAc,SAAI,GACjB,aAAa,EAAE,CAmDjB"}