@emeryld/rrroutes-contract 1.1.0

package/README.md

@@ -0,0 +1,61 @@
+# @emeryld/rrroutes-contract
+
+Core builder + registry utilities for RRRoutes. The contract package exposes the fluent DSL (`resource`, `withCrud`), the `finalize` helper, cache-key utilities, and all TypeScript inference helpers used by both the client and server packages.
+
+## Installation
+
+```sh
+pnpm add @emeryld/rrroutes-contract
+# or
+npm install @emeryld/rrroutes-contract
+```
+
+`zod` ships as a dependency so you do not need to install it separately.
+
+## Quick start
+
+```ts
+import { resource, finalize } from '@emeryld/rrroutes-contract';
+import { z } from 'zod';
+
+const users = resource('/v1')
+  .sub('users', (users) =>
+    users
+      .get({
+        querySchema: z.object({ search: z.string().optional() }),
+        outputSchema: z.array(z.object({ id: z.string().uuid(), email: z.string().email() })),
+      })
+      .routeParameter('userId', z.string().uuid(), (user) =>
+        user.get({
+          outputSchema: z.object({ id: z.string().uuid(), email: z.string().email() }),
+        }),
+      )
+      .done(),
+  )
+  .done();
+
+export const registry = finalize([...users]);
+```
+
+`registry.all` retains the readonly tuple of leaves, while `registry.byKey['GET /v1/users']` gives you autocomplete-safe access to a single endpoint.
+
+## Scripts
+
+Run everything from the repo root using pnpm:
+
+```sh
+pnpm install
+pnpm --filter @emeryld/rrroutes-contract build    # tsup + d.ts
+pnpm --filter @emeryld/rrroutes-contract test     # optional, via Jest
+```
+
+## Publishing
+
+Once the workspace is built, publish just this package from its folder:
+
+```sh
+cd packages/contract
+npm publish --access public
+```
+
+Make sure the version in `packages/contract/package.json` matches what you intend to release.

package/dist/core/routesV3.builder.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { AnyLeaf, Append, Leaf, Merge, MergeArray, MethodCfg, NodeCfg, Prettify } from './routesV3.core';
+type ZodTypeAny = z.ZodTypeAny;
+/**
+ * Runtime helper that mirrors the typed merge used by the builder.
+ * @param a Previously merged params schema inherited from parent segments.
+ * @param b Newly introduced params schema.
+ * @returns Intersection of schemas when both exist, otherwise whichever is defined.
+ */
+declare function mergeSchemas<A extends ZodTypeAny | undefined, B extends ZodTypeAny | undefined>(a: A, b: B): A extends ZodTypeAny ? (B extends ZodTypeAny ? ReturnType<typeof z.intersection<A, B>> : A) : B;
+/** Builder surface used by `resource(...)` to accumulate leaves. */
+export interface Branch<Base extends string, Acc extends readonly AnyLeaf[], I extends NodeCfg, PS extends ZodTypeAny | undefined> {
+    /**
+     * Enter or define a static child segment.
+     * Optionally accepts extra config and/or a builder to populate nested routes.
+     * @param name Child segment literal (no leading slash).
+     * @param cfg Optional node configuration to merge for descendants.
+     * @param builder Callback to produce leaves for the child branch.
+     */
+    sub<Name extends string, J extends NodeCfg>(name: Name, cfg?: J): Branch<`${Base}/${Name}`, Acc, Merge<I, NonNullable<J>>, PS>;
+    sub<Name extends string, J extends NodeCfg | undefined, R extends readonly AnyLeaf[]>(name: Name, cfg: J, builder: (r: Branch<`${Base}/${Name}`, readonly [], Merge<I, NonNullable<J>>, PS>) => R): Branch<Base, Append<Acc, R[number]>, Merge<I, NonNullable<J>>, PS>;
+    sub<Name extends string, R extends readonly AnyLeaf[]>(name: Name, builder: (r: Branch<`${Base}/${Name}`, readonly [], I, PS>) => R): Branch<Base, MergeArray<Acc, R>, I, PS>;
+    /**
+     * Introduce a `:param` segment and merge its schema into downstream leaves.
+     * @param name Parameter key (without leading colon).
+     * @param paramsSchema Zod schema for the parameter value.
+     * @param builder Callback that produces leaves beneath the parameterized segment.
+     */
+    routeParameter<Name extends string, P extends ZodTypeAny, R extends readonly AnyLeaf[]>(name: Name, paramsSchema: P, builder: (r: Branch<`${Base}/:${Name}`, readonly [], I, ReturnType<typeof mergeSchemas<PS, P>>>) => R): Branch<Base, MergeArray<Acc, R>, I, ReturnType<typeof mergeSchemas<PS, P>>>;
+    /**
+     * Merge additional node configuration that subsequent leaves will inherit.
+     * @param cfg Partial node configuration (e.g. `{ authenticated: true }`).
+     */
+    with<J extends NodeCfg>(cfg: J): Branch<Base, Acc, Merge<I, J>, PS>;
+    /**
+     * Register a GET leaf at the current path.
+     * @param cfg Method configuration (schemas, flags, descriptions, etc).
+     */
+    get<C extends Omit<MethodCfg, 'paramsSchema'>>(cfg: C): Branch<Base, Append<Acc, Prettify<Leaf<'get', Base, Merge<Merge<I, C>, {
+        paramsSchema: PS;
+    }>>>>, I, PS>;
+    /**
+     * Register a POST leaf at the current path.
+     * @param cfg Method configuration (schemas, flags, descriptions, etc).
+     */
+    post<C extends Omit<MethodCfg, 'paramsSchema'>>(cfg: C): Branch<Base, Append<Acc, Leaf<'post', Base, Merge<Merge<I, C>, {
+        paramsSchema: PS;
+    }>>>, I, PS>;
+    /**
+     * Register a PUT leaf at the current path.
+     * @param cfg Method configuration (schemas, flags, descriptions, etc).
+     */
+    put<C extends Omit<MethodCfg, 'paramsSchema'>>(cfg: C): Branch<Base, Append<Acc, Leaf<'put', Base, Merge<Merge<I, C>, {
+        paramsSchema: PS;
+    }>>>, I, PS>;
+    /**
+     * Register a PATCH leaf at the current path.
+     * @param cfg Method configuration (schemas, flags, descriptions, etc).
+     */
+    patch<C extends Omit<MethodCfg, 'paramsSchema'>>(cfg: C): Branch<Base, Append<Acc, Leaf<'patch', Base, Merge<Merge<I, C>, {
+        paramsSchema: PS;
+    }>>>, I, PS>;
+    /**
+     * Register a DELETE leaf at the current path.
+     * @param cfg Method configuration (schemas, flags, descriptions, etc).
+     */
+    delete<C extends Omit<MethodCfg, 'paramsSchema'>>(cfg: C): Branch<Base, Append<Acc, Leaf<'delete', Base, Merge<Merge<I, C>, {
+        paramsSchema: PS;
+    }>>>, I, PS>;
+    /**
+     * Finish the branch and return the collected leaves.
+     * @returns Readonly tuple of accumulated leaves.
+     */
+    done(): Readonly<Acc>;
+}
+/**
+ * Start building a resource at the given base path.
+ * @param base Root path for the resource (e.g. `/v1`).
+ * @param inherited Optional node configuration applied to all descendants.
+ * @returns Root `Branch` instance used to compose the route tree.
+ */
+export declare function resource<Base extends string, I extends NodeCfg = {}>(base: Base, inherited?: I): Branch<Base, readonly [], I, undefined>;
+/**
+ * Merge two readonly tuples (preserves literal tuple information).
+ * @param arr1 First tuple.
+ * @param arr2 Second tuple.
+ * @returns New tuple containing values from both inputs.
+ */
+export declare const mergeArrays: <T extends readonly any[], S extends readonly any[]>(arr1: T, arr2: S) => [...T, ...S];
+export {};

package/dist/core/routesV3.core.d.ts

@@ -0,0 +1,90 @@
+import { z, ZodTypeAny } from 'zod';
+/** Supported HTTP verbs for the routes DSL. */
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+/** Declarative description of a multipart upload field. */
+export type FileField = {
+    /** Form field name used for uploads. */
+    name: string;
+    /** Maximum number of files accepted for this field. */
+    maxCount: number;
+};
+/** Configuration that applies to an entire branch of the route tree. */
+export type NodeCfg = {
+    /** When true, descendant routes require authentication. */
+    authenticated?: boolean;
+};
+/** Per-method configuration merged with inherited node config. */
+export type MethodCfg = NodeCfg & {
+    /** Zod schema describing the request body. */
+    bodySchema?: ZodTypeAny;
+    /** Zod schema describing the query string. */
+    querySchema?: ZodTypeAny;
+    /** Zod schema describing path params (overrides inferred params). */
+    paramsSchema?: ZodTypeAny;
+    /** Zod schema describing the response payload. */
+    outputSchema?: ZodTypeAny;
+    /** Multipart upload definitions for the route. */
+    bodyFiles?: FileField[];
+    /** Marks the route as an infinite feed (enables cursor helpers). */
+    feed?: boolean;
+    /** Optional human-readable description for docs/debugging. */
+    description?: string;
+};
+/** Immutable representation of a single HTTP route in the tree. */
+export type Leaf<M extends HttpMethod, P extends string, C extends MethodCfg> = {
+    /** Lowercase HTTP method (get/post/...). */
+    readonly method: M;
+    /** Concrete path for the route (e.g. `/v1/users/:userId`). */
+    readonly path: P;
+    /** Readonly snapshot of route configuration. */
+    readonly cfg: Readonly<C>;
+};
+/** Convenience union covering all generated leaves. */
+export type AnyLeaf = Leaf<HttpMethod, string, MethodCfg>;
+/** Merge two object types while keeping nice IntelliSense output. */
+export type Merge<A, B> = Prettify<Omit<A, keyof B> & B>;
+/** Append a new element to a readonly tuple type. */
+export type Append<T extends readonly unknown[], X> = [...T, X];
+/** Concatenate two readonly tuple types. */
+export type MergeArray<A extends readonly unknown[], B extends readonly unknown[]> = [
+    ...A,
+    ...B
+];
+type SegmentParams<S extends string> = S extends `:${infer P}` ? P : never;
+type Split<S extends string> = S extends '' ? [] : S extends `${infer A}/${infer B}` ? [A, ...Split<B>] : [S];
+type ExtractParamNames<Path extends string> = SegmentParams<Split<Path>[number]>;
+/** Derive a params object type from a literal route string. */
+export type ExtractParamsFromPath<Path extends string> = ExtractParamNames<Path> extends never ? never : Record<ExtractParamNames<Path>, string | number>;
+/**
+ * Interpolate `:params` in a path using the given values.
+ * @param path Literal route string containing `:param` segments.
+ * @param params Object of parameter values to interpolate.
+ * @returns Path string with parameters substituted.
+ */
+export declare function compilePath<Path extends string>(path: Path, params: ExtractParamsFromPath<Path>): string;
+/**
+ * Build a deterministic cache key for the given leaf.
+ * The key matches the shape consumed by React Query helpers.
+ * @param args.leaf Leaf describing the endpoint.
+ * @param args.params Optional params used to build the path.
+ * @param args.query Optional query payload.
+ * @returns Tuple suitable for React Query cache keys.
+ */
+export declare function buildCacheKey<L extends AnyLeaf>(args: {
+    leaf: L;
+    params?: ExtractParamsFromPath<L['path']>;
+    query?: InferQuery<L>;
+}): readonly [HttpMethod, ...string[], {}];
+/** Infer params either from the explicit params schema or from the path literal. */
+export type InferParams<L extends AnyLeaf> = L['cfg']['paramsSchema'] extends ZodTypeAny ? z.infer<L['cfg']['paramsSchema']> : ExtractParamsFromPath<L['path']>;
+/** Infer query shape from a Zod schema when present. */
+export type InferQuery<L extends AnyLeaf> = L['cfg']['querySchema'] extends ZodTypeAny ? z.infer<L['cfg']['querySchema']> : never;
+/** Infer request body shape from a Zod schema when present. */
+export type InferBody<L extends AnyLeaf> = L['cfg']['bodySchema'] extends ZodTypeAny ? z.infer<L['cfg']['bodySchema']> : never;
+/** Infer handler output shape from a Zod schema. Defaults to unknown. */
+export type InferOutput<L extends AnyLeaf> = L['cfg']['outputSchema'] extends ZodTypeAny ? z.infer<L['cfg']['outputSchema']> : unknown;
+/** Render a type as if it were a simple object literal. */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export {};

package/dist/core/routesV3.finalize.d.ts

@@ -0,0 +1,40 @@
+import { AnyLeaf, HttpMethod } from './routesV3.core';
+/** Build the key type for a leaf — distributive so method/path stay paired. */
+export type KeyOf<L extends AnyLeaf> = L extends AnyLeaf ? `${Uppercase<L['method']>} ${L['path']}` : never;
+type MethodFromKey<K extends string> = K extends `${infer M} ${string}` ? Lowercase<M> : never;
+type PathFromKey<K extends string> = K extends `${string} ${infer P}` ? P : never;
+/**
+ * Freeze a leaf tuple into a registry with typed key lookups.
+ * @param leaves Readonly tuple of leaves produced by the builder DSL.
+ * @returns Registry containing the leaves array and a `byKey` lookup map.
+ */
+export declare function finalize<const L extends readonly AnyLeaf[]>(leaves: L): {
+    all: L;
+    byKey: { [K in KeyOf<L[number]>]: Extract<L[number], {
+        method: MethodFromKey<K> & HttpMethod;
+        path: PathFromKey<K>;
+    }> extends infer T ? { [K_1 in keyof T]: T[K_1]; } : never; };
+    log: (logger: {
+        system: (...args: unknown[]) => void;
+    }) => void;
+};
+/** Nominal type alias for a finalized registry. */
+export type Registry<R extends ReturnType<typeof finalize>> = R;
+type FilterRoute<T extends readonly AnyLeaf[], F extends string, Acc extends readonly AnyLeaf[] = []> = T extends readonly [infer First extends AnyLeaf, ...infer Rest extends AnyLeaf[]] ? First extends {
+    path: `${string}${F}${string}`;
+} ? FilterRoute<Rest, F, [...Acc, First]> : FilterRoute<Rest, F, Acc> : Acc;
+type UpperCase<S extends string> = S extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${UpperCase<Rest>}` : S;
+type Routes<T extends readonly AnyLeaf[], F extends string> = FilterRoute<T, F>;
+type ByKey<T extends readonly AnyLeaf[], Acc extends Record<string, AnyLeaf> = {}> = T extends readonly [infer First extends AnyLeaf, ...infer Rest extends AnyLeaf[]] ? ByKey<Rest, Acc & {
+    [K in `${UpperCase<First['method']>} ${First['path']}`]: First;
+}> : Acc;
+/**
+ * Convenience helper for extracting a subset of routes by path fragment.
+ * @param T Tuple of leaves produced by the DSL.
+ * @param F String fragment to match against the route path.
+ */
+export type SubsetRoutes<T extends readonly AnyLeaf[], F extends string> = {
+    byKey: ByKey<Routes<T, F>>;
+    all: Routes<T, F>;
+};
+export {};

package/dist/crud/routesV3.crud.d.ts

@@ -0,0 +1,200 @@
+import { z, type ZodTypeAny } from 'zod';
+import { resource as baseResource, type Branch as _Branch } from '../core/routesV3.builder';
+import { type AnyLeaf, type Leaf, type NodeCfg } from '../core/routesV3.core';
+/** Default cursor pagination used by list (GET collection). */
+export declare const CrudDefaultPagination: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Merge two Zod schemas at runtime; matches the typing pattern used in builder.
+ * @param a Existing params schema inherited from parent branches.
+ * @param b Schema introduced at the current branch.
+ * @returns Intersection of schemas when both exist, otherwise whichever is defined.
+ */
+export declare function mergeSchemas<A extends ZodTypeAny | undefined, B extends ZodTypeAny | undefined>(a: A, b: B): A extends ZodTypeAny ? (B extends ZodTypeAny ? ReturnType<typeof z.intersection<A, B>> : A) : B;
+/** Build { [Name]: S } Zod object at the type-level. */
+export type ParamSchema<Name extends string, S extends ZodTypeAny> = z.ZodObject<{
+    [K in Name]: S;
+}>;
+/** Inject active params schema into a leaf cfg (to match your Leaf typing). */
+type WithParams<I, P> = P extends ZodTypeAny ? Omit<I, 'paramsSchema'> & {
+    paramsSchema: P;
+} : I;
+/** Resolve boolean flag: default D unless explicitly false. */
+type Flag<E, D extends boolean> = E extends false ? false : D;
+/** Toggle individual CRUD methods; defaults enable all (create/update require body). */
+export type CrudEnable = {
+    /** GET /collection (feed). Defaults to true. */ list?: boolean;
+    /** POST /collection. Defaults to true if `create` provided. */ create?: boolean;
+    /** GET /collection/:id. Defaults to true. */ read?: boolean;
+    /** PATCH /collection/:id. Defaults to true if `update` provided. */ update?: boolean;
+    /** DELETE /collection/:id. Defaults to true. */ remove?: boolean;
+};
+/** Collection GET config. */
+export type CrudListCfg = {
+    /** Query schema (defaults to cursor pagination). */
+    querySchema?: ZodTypeAny;
+    /** Output schema (defaults to { items: Item[], nextCursor? }). */
+    outputSchema?: ZodTypeAny;
+    /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */
+    authenticated?: boolean;
+    /** Optional description string. */
+    description?: string;
+};
+/** Collection POST config. */
+export type CrudCreateCfg = {
+    /** Body schema for creating an item. */
+    bodySchema: ZodTypeAny;
+    /** Output schema (defaults to itemOutputSchema). */
+    outputSchema?: ZodTypeAny;
+    /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */
+    authenticated?: boolean;
+    /** Optional description. */
+    description?: string;
+};
+/** Item GET config. */
+export type CrudReadCfg = {
+    /** Output schema (defaults to itemOutputSchema). */
+    outputSchema?: ZodTypeAny;
+    /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */
+    authenticated?: boolean;
+    /** Optional description. */
+    description?: string;
+};
+/** Item PATCH config. */
+export type CrudUpdateCfg = {
+    /** Body schema for partial updates. */
+    bodySchema: ZodTypeAny;
+    /** Output schema (defaults to itemOutputSchema). */
+    outputSchema?: ZodTypeAny;
+    /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */
+    authenticated?: boolean;
+    /** Optional description. */
+    description?: string;
+};
+/** Item DELETE config. */
+export type CrudRemoveCfg = {
+    /** Output schema (defaults to { ok: true }). */
+    outputSchema?: ZodTypeAny;
+    /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */
+    authenticated?: boolean;
+    /** Optional description. */
+    description?: string;
+};
+/**
+ * CRUD config for `.crud("resource", cfg, extras?)`.
+ *
+ * It synthesizes `:[resourceName]Id` as the param key and uses `paramSchema` for the value.
+ * Prefer passing a **value schema** (e.g. `z.string().uuid()`).
+ * As a convenience, a ZodObject of shape `{ [resourceName]Id: schema }` is accepted at runtime too.
+ */
+export type CrudCfg<Name extends string = string> = {
+    /**
+     * Zod schema for the ID *value* (e.g. `z.string().uuid()`).
+     * The parameter key is always `:${name}Id`.
+     * (If you pass `z.object({ [name]Id: ... })`, it's accepted at runtime.)
+     */
+    paramSchema: ZodTypeAny;
+    /**
+     * The single-item output shape used by read/create/update by default.
+     * List defaults to `{ items: z.array(itemOutputSchema), nextCursor? }`.
+     */
+    itemOutputSchema: ZodTypeAny;
+    /** Per-method toggles (all enabled by default; create/update require bodies). */
+    enable?: CrudEnable;
+    /** GET /collection configuration. */ list?: CrudListCfg;
+    /** POST /collection configuration (enables create). */ create?: CrudCreateCfg;
+    /** GET /collection/:id configuration. */ read?: CrudReadCfg;
+    /** PATCH /collection/:id configuration (enables update). */ update?: CrudUpdateCfg;
+    /** DELETE /collection/:id configuration. */ remove?: CrudRemoveCfg;
+};
+type CrudLeavesTuple<Base extends string, I extends NodeCfg, PS extends ZodTypeAny | undefined, Name extends string, C extends CrudCfg<Name>> = `${Name}Id` extends infer IdName extends string ? ParamSchema<IdName, C['paramSchema']> extends infer IdParamZ extends ZodTypeAny ? [
+    ...(Flag<C['enable'] extends CrudEnable ? C['enable']['list'] : undefined, true> extends true ? [
+        Leaf<'get', `${Base}/${Name}`, WithParams<Omit<I, never> & {
+            feed: true;
+            querySchema: C['list'] extends CrudListCfg ? C['list']['querySchema'] : typeof CrudDefaultPagination;
+            outputSchema: C['list'] extends CrudListCfg ? C['list']['outputSchema'] extends ZodTypeAny ? C['list']['outputSchema'] : z.ZodObject<{
+                items: z.ZodArray<C['itemOutputSchema']>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }> : z.ZodObject<{
+                items: z.ZodArray<C['itemOutputSchema']>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }>;
+            description?: string;
+        }, PS>>
+    ] : []),
+    ...((C['create'] extends CrudCreateCfg ? true : false) extends true ? Flag<C['enable'] extends CrudEnable ? C['enable']['create'] : undefined, true> extends true ? [
+        Leaf<'post', `${Base}/${Name}`, WithParams<Omit<I, never> & {
+            bodySchema: C['create'] extends CrudCreateCfg ? C['create']['bodySchema'] : never;
+            outputSchema: C['create'] extends CrudCreateCfg ? C['create']['outputSchema'] extends ZodTypeAny ? C['create']['outputSchema'] : C['itemOutputSchema'] : never;
+            description?: string;
+        }, PS>>
+    ] : [] : []),
+    ...(Flag<C['enable'] extends CrudEnable ? C['enable']['read'] : undefined, true> extends true ? [
+        Leaf<'get', `${Base}/${Name}/:${IdName}`, WithParams<Omit<I, never> & {
+            outputSchema: C['read'] extends CrudReadCfg ? C['read']['outputSchema'] extends ZodTypeAny ? C['read']['outputSchema'] : C['itemOutputSchema'] : C['itemOutputSchema'];
+            description?: string;
+        }, ReturnType<typeof mergeSchemas<PS, IdParamZ>>>>
+    ] : []),
+    ...((C['update'] extends CrudUpdateCfg ? true : false) extends true ? Flag<C['enable'] extends CrudEnable ? C['enable']['update'] : undefined, true> extends true ? [
+        Leaf<'patch', `${Base}/${Name}/:${IdName}`, WithParams<Omit<I, never> & {
+            bodySchema: C['update'] extends CrudUpdateCfg ? C['update']['bodySchema'] : never;
+            outputSchema: C['update'] extends CrudUpdateCfg ? C['update']['outputSchema'] extends ZodTypeAny ? C['update']['outputSchema'] : C['itemOutputSchema'] : never;
+            description?: string;
+        }, ReturnType<typeof mergeSchemas<PS, IdParamZ>>>>
+    ] : [] : []),
+    ...(Flag<C['enable'] extends CrudEnable ? C['enable']['remove'] : undefined, true> extends true ? [
+        Leaf<'delete', `${Base}/${Name}/:${IdName}`, WithParams<Omit<I, never> & {
+            outputSchema: C['remove'] extends CrudRemoveCfg ? C['remove']['outputSchema'] extends ZodTypeAny ? C['remove']['outputSchema'] : z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }> : z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }>;
+            description?: string;
+        }, ReturnType<typeof mergeSchemas<PS, IdParamZ>>>>
+    ] : [])
+] : never : never;
+/** Merge generated leaves + extras into the branch accumulator. */
+type CrudResultAcc<Base extends string, Acc extends readonly AnyLeaf[], I extends NodeCfg, PS extends ZodTypeAny | undefined, Name extends string, C extends CrudCfg<Name>, Extras extends readonly AnyLeaf[]> = [...Acc, ...CrudLeavesTuple<Base, I, PS, Name, C>, ...Extras];
+declare module './../core/routesV3.builder' {
+    interface Branch<Base extends string, Acc extends readonly AnyLeaf[], I extends NodeCfg, PS extends ZodTypeAny | undefined> {
+        /**
+         * Generate opinionated CRUD endpoints for a collection at `/.../<name>`
+         * with an item at `/.../<name>/:<name>Id`.
+         *
+         * Creates (subject to `enable` + presence of create/update bodies):
+         * - GET    /<name>                (feed list)
+         * - POST   /<name>                (create)
+         * - GET    /<name>/:<name>Id      (read item)
+         * - PATCH  /<name>/:<name>Id      (update item)
+         * - DELETE /<name>/:<name>Id      (remove item)
+         *
+         * The `extras` callback receives live builders at both collection and item
+         * levels so you can add custom subroutes; their leaves are included in the
+         * returned Branch type.
+         */
+        crud<Name extends string, C extends CrudCfg<Name>, Extras extends readonly AnyLeaf[] = readonly []>(name: Name, cfg: C, extras?: (ctx: {
+            /** Builder at `/.../<name>` (collection scope). */
+            collection: _Branch<`${Base}/${Name}`, readonly [], I, PS>;
+            /** Builder at `/.../<name>/:<name>Id` (item scope). */
+            item: _Branch<`${Base}/${Name}/:${`${Name}Id`}`, readonly [], I, ReturnType<typeof mergeSchemas<PS, ParamSchema<`${Name}Id`, C['paramSchema']>>>>;
+        }) => Extras): _Branch<Base, CrudResultAcc<Base, Acc, I, PS, Name, C, Extras>, I, PS>;
+    }
+}
+/**
+ * Decorate a Branch instance so `.crud(...)` is available at runtime.
+ * Tip: wrap the root: `withCrud(resource('/v1'))`.
+ * @param branch Branch returned by `resource(...)`.
+ * @returns Same branch with `.crud(...)` installed.
+ */
+export declare function withCrud<Base extends string, Acc extends readonly AnyLeaf[], I extends NodeCfg, PS extends ZodTypeAny | undefined>(branch: _Branch<Base, Acc, I, PS>): _Branch<Base, Acc, I, PS>;
+/**
+ * Drop-in replacement for `resource(...)` that returns a Branch with `.crud()` installed.
+ * You can either use this or call `withCrud(resource(...))`.
+ * @param base Root path for the resource (e.g. `/v1`).
+ * @param inherited Node configuration merged into every leaf.
+ * @returns Branch builder that already includes the CRUD helper.
+ */
+export declare function resourceWithCrud<Base extends string, I extends NodeCfg = {}>(base: Base, inherited: I): _Branch<Base, readonly [], I, undefined>;
+export { baseResource as resource };

package/dist/index.cjs

@@ -0,0 +1,251 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CrudDefaultPagination: () => CrudDefaultPagination,
+  buildCacheKey: () => buildCacheKey,
+  compilePath: () => compilePath,
+  finalize: () => finalize,
+  mergeArrays: () => mergeArrays,
+  mergeSchemas: () => mergeSchemas2,
+  resource: () => resource,
+  resourceWithCrud: () => resourceWithCrud,
+  withCrud: () => withCrud
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/routesV3.builder.ts
+var import_zod = require("zod");
+function mergeSchemas(a, b) {
+  if (a && b) return import_zod.z.intersection(a, b);
+  return a ?? b;
+}
+function resource(base, inherited) {
+  const rootBase = base;
+  const rootInherited = { ...inherited };
+  function makeBranch(base2, inherited2, mergedParamsSchema) {
+    const stack = [];
+    let currentBase = base2;
+    let inheritedCfg = { ...inherited2 };
+    let currentParamsSchema = mergedParamsSchema;
+    function add(method, cfg) {
+      const effectiveParamsSchema = cfg.paramsSchema ?? currentParamsSchema;
+      const fullCfg = effectiveParamsSchema ? { ...inheritedCfg, ...cfg, paramsSchema: effectiveParamsSchema } : { ...inheritedCfg, ...cfg };
+      const leaf = {
+        method,
+        path: currentBase,
+        cfg: fullCfg
+      };
+      stack.push(leaf);
+      return api;
+    }
+    const api = {
+      // compose a plain subpath (optional cfg) with optional builder
+      sub(name, cfgOrBuilder, maybeBuilder) {
+        let cfg;
+        let builder;
+        if (typeof cfgOrBuilder === "function") {
+          builder = cfgOrBuilder;
+        } else {
+          cfg = cfgOrBuilder;
+          builder = maybeBuilder;
+        }
+        const childBase = `${currentBase}/${name}`;
+        const childInherited = { ...inheritedCfg, ...cfg ?? {} };
+        if (builder) {
+          const child = makeBranch(childBase, childInherited, currentParamsSchema);
+          const leaves = builder(child);
+          for (const l of leaves) stack.push(l);
+          return api;
+        } else {
+          currentBase = childBase;
+          inheritedCfg = childInherited;
+          return api;
+        }
+      },
+      // the single param function: name + schema + builder
+      routeParameter(name, paramsSchema, builder) {
+        const childBase = `${currentBase}/:${name}`;
+        const childParams = mergeSchemas(currentParamsSchema, paramsSchema);
+        const child = makeBranch(childBase, inheritedCfg, childParams);
+        const leaves = builder(child);
+        for (const l of leaves) stack.push(l);
+        return api;
+      },
+      with(cfg) {
+        inheritedCfg = { ...inheritedCfg, ...cfg };
+        return api;
+      },
+      // methods (inject current params schema if missing)
+      get(cfg) {
+        return add("get", cfg);
+      },
+      post(cfg) {
+        return add("post", { ...cfg, feed: false });
+      },
+      put(cfg) {
+        return add("put", { ...cfg, feed: false });
+      },
+      patch(cfg) {
+        return add("patch", { ...cfg, feed: false });
+      },
+      delete(cfg) {
+        return add("delete", { ...cfg, feed: false });
+      },
+      done() {
+        return stack;
+      }
+    };
+    return api;
+  }
+  return makeBranch(rootBase, rootInherited, void 0);
+}
+var mergeArrays = (arr1, arr2) => {
+  return [...arr1, ...arr2];
+};
+
+// src/core/routesV3.core.ts
+function compilePath(path, params) {
+  if (!params) return path;
+  return path.replace(/:([A-Za-z0-9_]+)/g, (_, k) => {
+    const v = params[k];
+    if (v === void 0 || v === null) throw new Error(`Missing param :${k}`);
+    return String(v);
+  });
+}
+function buildCacheKey(args) {
+  let p = args.leaf.path;
+  if (args.params) {
+    p = compilePath(p, args.params);
+  }
+  return [args.leaf.method, ...p.split("/").filter(Boolean), args.query ?? {}];
+}
+
+// src/core/routesV3.finalize.ts
+function finalize(leaves) {
+  const byKey = Object.fromEntries(
+    leaves.map((l) => [`${l.method.toUpperCase()} ${l.path}`, l])
+  );
+  const log = (logger) => {
+    logger.system("Finalized routes:");
+    Object.keys(byKey).forEach((k) => {
+      const leaf = byKey[k];
+      logger.system(`- ${k} (auth: ${leaf.cfg.authenticated ? "yes" : "no"})`);
+    });
+  };
+  return { all: leaves, byKey, log };
+}
+
+// src/crud/routesV3.crud.ts
+var import_zod2 = require("zod");
+var CrudDefaultPagination = import_zod2.z.object({
+  limit: import_zod2.z.coerce.number().min(1).max(100).default(20),
+  cursor: import_zod2.z.string().optional()
+});
+function mergeSchemas2(a, b) {
+  if (a && b) return import_zod2.z.intersection(a, b);
+  return a ?? b;
+}
+function withCrud(branch) {
+  const b = branch;
+  if (typeof b.crud === "function") return branch;
+  b.crud = function(name, cfg, extras) {
+    return this.sub(name, (collection) => {
+      const idKey = `${name}Id`;
+      const s = cfg.paramSchema;
+      const isObj = s && typeof s._def === "object" && s._def.typeName === "ZodObject" && typeof s.shape === "function";
+      const paramObj = isObj && s.shape()[idKey] ? s : import_zod2.z.object({ [idKey]: s });
+      const itemOut = cfg.itemOutputSchema;
+      const listOut = cfg.list?.outputSchema ?? import_zod2.z.object({
+        items: import_zod2.z.array(itemOut),
+        nextCursor: import_zod2.z.string().optional()
+      });
+      const want = {
+        list: cfg.enable?.list !== false,
+        create: cfg.enable?.create !== false && !!cfg.create?.bodySchema,
+        read: cfg.enable?.read !== false,
+        update: cfg.enable?.update !== false && !!cfg.update?.bodySchema,
+        remove: cfg.enable?.remove !== false
+      };
+      if (want.list) {
+        const c = cfg.list?.authenticated ? collection.with({ authenticated: true }) : collection;
+        c.get({
+          feed: true,
+          querySchema: cfg.list?.querySchema ?? CrudDefaultPagination,
+          outputSchema: listOut,
+          description: cfg.list?.description ?? "List"
+        });
+      }
+      if (want.create) {
+        const c = cfg.create?.authenticated ? collection.with({ authenticated: true }) : collection;
+        c.post({
+          bodySchema: cfg.create.bodySchema,
+          outputSchema: cfg.create?.outputSchema ?? itemOut,
+          description: cfg.create?.description ?? "Create"
+        });
+      }
+      collection.routeParameter(idKey, paramObj, (item) => {
+        if (want.read) {
+          const i = cfg.read?.authenticated ? item.with({ authenticated: true }) : item;
+          i.get({
+            outputSchema: cfg.read?.outputSchema ?? itemOut,
+            description: cfg.read?.description ?? "Read"
+          });
+        }
+        if (want.update) {
+          const i = cfg.update?.authenticated ? item.with({ authenticated: true }) : item;
+          i.patch({
+            bodySchema: cfg.update.bodySchema,
+            outputSchema: cfg.update?.outputSchema ?? itemOut,
+            description: cfg.update?.description ?? "Update"
+          });
+        }
+        if (want.remove) {
+          const i = cfg.remove?.authenticated ? item.with({ authenticated: true }) : item;
+          i.delete({
+            outputSchema: cfg.remove?.outputSchema ?? import_zod2.z.object({ ok: import_zod2.z.literal(true) }),
+            description: cfg.remove?.description ?? "Delete"
+          });
+        }
+        if (extras) extras({ collection: withCrud(collection), item: withCrud(item) });
+        return item.done();
+      });
+      return collection.done();
+    });
+  };
+  return branch;
+}
+function resourceWithCrud(base, inherited) {
+  return withCrud(resource(base, inherited));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CrudDefaultPagination,
+  buildCacheKey,
+  compilePath,
+  finalize,
+  mergeArrays,
+  mergeSchemas,
+  resource,
+  resourceWithCrud,
+  withCrud
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/core/routesV3.builder.ts","../src/core/routesV3.core.ts","../src/core/routesV3.finalize.ts","../src/crud/routesV3.crud.ts"],"sourcesContent":["export * from './core/routesV3.builder';\nexport * from './core/routesV3.core';\nexport * from './core/routesV3.finalize';\nexport * from './crud/routesV3.crud';","import { z } from 'zod';\nimport {\n  AnyLeaf,\n  Append,\n  HttpMethod,\n  Leaf,\n  Merge,\n  MergeArray,\n  MethodCfg,\n  NodeCfg,\n  Prettify,\n} from './routesV3.core';\n\ntype ZodTypeAny = z.ZodTypeAny;\n\n/**\n * Runtime helper that mirrors the typed merge used by the builder.\n * @param a Previously merged params schema inherited from parent segments.\n * @param b Newly introduced params schema.\n * @returns Intersection of schemas when both exist, otherwise whichever is defined.\n */\nfunction mergeSchemas<A extends ZodTypeAny | undefined, B extends ZodTypeAny | undefined>(\n  a: A,\n  b: B,\n): A extends ZodTypeAny ? (B extends ZodTypeAny ? ReturnType<typeof z.intersection<A, B>> : A) : B {\n  if (a && b) return z.intersection(a as any, b as any) as any;\n  return (a ?? b) as any;\n}\n\n/** Builder surface used by `resource(...)` to accumulate leaves. */\nexport interface Branch<\n  Base extends string,\n  Acc extends readonly AnyLeaf[],\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n> {\n  // --- structure ---\n  /**\n   * Enter or define a static child segment.\n   * Optionally accepts extra config and/or a builder to populate nested routes.\n   * @param name Child segment literal (no leading slash).\n   * @param cfg Optional node configuration to merge for descendants.\n   * @param builder Callback to produce leaves for the child branch.\n   */\n  sub<Name extends string, J extends NodeCfg>(\n    name: Name,\n    cfg?: J,\n  ): Branch<`${Base}/${Name}`, Acc, Merge<I, NonNullable<J>>, PS>;\n\n  sub<Name extends string, J extends NodeCfg | undefined, R extends readonly AnyLeaf[]>(\n    name: Name,\n    cfg: J,\n    builder: (r: Branch<`${Base}/${Name}`, readonly [], Merge<I, NonNullable<J>>, PS>) => R,\n  ): Branch<Base, Append<Acc, R[number]>, Merge<I, NonNullable<J>>, PS>;\n\n  sub<Name extends string, R extends readonly AnyLeaf[]>(\n    name: Name,\n    builder: (r: Branch<`${Base}/${Name}`, readonly [], I, PS>) => R,\n  ): Branch<Base, MergeArray<Acc, R>, I, PS>;\n\n  // --- parameterized segment (single signature) ---\n  /**\n   * Introduce a `:param` segment and merge its schema into downstream leaves.\n   * @param name Parameter key (without leading colon).\n   * @param paramsSchema Zod schema for the parameter value.\n   * @param builder Callback that produces leaves beneath the parameterized segment.\n   */\n  routeParameter<Name extends string, P extends ZodTypeAny, R extends readonly AnyLeaf[]>(\n    name: Name,\n    paramsSchema: P,\n    builder: (\n      r: Branch<`${Base}/:${Name}`, readonly [], I, ReturnType<typeof mergeSchemas<PS, P>>>,\n    ) => R,\n  ): Branch<Base, MergeArray<Acc, R>, I, ReturnType<typeof mergeSchemas<PS, P>>>;\n\n  // --- flags inheritance ---\n  /**\n   * Merge additional node configuration that subsequent leaves will inherit.\n   * @param cfg Partial node configuration (e.g. `{ authenticated: true }`).\n   */\n  with<J extends NodeCfg>(cfg: J): Branch<Base, Acc, Merge<I, J>, PS>;\n\n  // --- methods (return Branch to keep chaining) ---\n  /**\n   * Register a GET leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  get<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<\n    Base,\n    Append<Acc, Prettify<Leaf<'get', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>>,\n    I,\n    PS\n  >;\n\n  /**\n   * Register a POST leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  post<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<Base, Append<Acc, Leaf<'post', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>, I, PS>;\n\n  /**\n   * Register a PUT leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  put<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<Base, Append<Acc, Leaf<'put', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>, I, PS>;\n\n  /**\n   * Register a PATCH leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  patch<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<\n    Base,\n    Append<Acc, Leaf<'patch', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>,\n    I,\n    PS\n  >;\n\n  /**\n   * Register a DELETE leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  delete<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<\n    Base,\n    Append<Acc, Leaf<'delete', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>,\n    I,\n    PS\n  >;\n\n  // --- finalize this subtree ---\n  /**\n   * Finish the branch and return the collected leaves.\n   * @returns Readonly tuple of accumulated leaves.\n   */\n  done(): Readonly<Acc>;\n}\n\n/**\n * Start building a resource at the given base path.\n * @param base Root path for the resource (e.g. `/v1`).\n * @param inherited Optional node configuration applied to all descendants.\n * @returns Root `Branch` instance used to compose the route tree.\n */\nexport function resource<Base extends string, I extends NodeCfg = {}>(\n  base: Base,\n  inherited?: I,\n): Branch<Base, readonly [], I, undefined> {\n  const rootBase = base;\n  const rootInherited: NodeCfg = { ...(inherited as NodeCfg) };\n\n  function makeBranch<Base2 extends string, I2 extends NodeCfg, PS2 extends ZodTypeAny | undefined>(\n    base2: Base2,\n    inherited2: I2,\n    mergedParamsSchema?: PS2,\n  ) {\n    const stack: AnyLeaf[] = [];\n    let currentBase: string = base2;\n    let inheritedCfg: NodeCfg = { ...(inherited2 as NodeCfg) };\n    let currentParamsSchema: PS2 = mergedParamsSchema as PS2;\n\n    function add<M extends HttpMethod, C extends MethodCfg>(method: M, cfg: C) {\n      // If the method didn’t provide a paramsSchema, inject the active merged one.\n      const effectiveParamsSchema = (cfg.paramsSchema ?? currentParamsSchema) as PS2 | undefined;\n      const fullCfg = (\n        effectiveParamsSchema\n          ? { ...inheritedCfg, ...cfg, paramsSchema: effectiveParamsSchema }\n          : { ...inheritedCfg, ...cfg }\n      ) as Merge<I2, C>;\n\n      const leaf = {\n        method,\n        path: currentBase as Base2,\n        cfg: fullCfg,\n      } as const;\n\n      stack.push(leaf as unknown as AnyLeaf);\n\n      // Return same runtime obj, but with Acc including this new leaf\n      return api as unknown as Branch<Base2, Append<readonly [], typeof leaf>, I2, PS2>;\n    }\n\n    const api: any = {\n      // compose a plain subpath (optional cfg) with optional builder\n      sub<Name extends string, J extends NodeCfg | undefined = undefined>(\n        name: Name,\n        cfgOrBuilder?: J | ((r: any) => readonly AnyLeaf[]),\n        maybeBuilder?: (r: any) => readonly AnyLeaf[],\n      ) {\n        let cfg: NodeCfg | undefined;\n        let builder: ((r: any) => readonly AnyLeaf[]) | undefined;\n\n        if (typeof cfgOrBuilder === 'function') {\n          builder = cfgOrBuilder as any;\n        } else {\n          cfg = cfgOrBuilder as NodeCfg | undefined;\n          builder = maybeBuilder;\n        }\n\n        const childBase = `${currentBase}/${name}` as const;\n        const childInherited = { ...inheritedCfg, ...(cfg ?? {}) } as Merge<I2, NonNullable<J>>;\n\n        if (builder) {\n          // params schema PS2 flows through unchanged on plain sub\n          const child = makeBranch(childBase, childInherited, currentParamsSchema);\n          const leaves = builder(child) as readonly AnyLeaf[];\n          for (const l of leaves) stack.push(l);\n          return api as Branch<\n            Base2,\n            Append<readonly [], (typeof leaves)[number]>,\n            typeof childInherited,\n            PS2\n          >;\n        } else {\n          currentBase = childBase;\n          inheritedCfg = childInherited;\n          return api as Branch<`${Base2}/${Name}`, readonly [], typeof childInherited, PS2>;\n        }\n      },\n\n      // the single param function: name + schema + builder\n      routeParameter<Name extends string, P extends ZodTypeAny, R extends readonly AnyLeaf[]>(\n        name: Name,\n        paramsSchema: P,\n        builder: (\n          r: Branch<`${Base2}/:${Name}`, readonly [], I2, ReturnType<typeof mergeSchemas<PS2, P>>>,\n        ) => R,\n      ) {\n        const childBase = `${currentBase}/:${name}` as const;\n        // Merge existing PS2 with P to create the child’s active params schema\n        const childParams = mergeSchemas(currentParamsSchema, paramsSchema);\n        const child = makeBranch(childBase, inheritedCfg as I2, childParams);\n        const leaves = builder(child) as readonly AnyLeaf[];\n        for (const l of leaves) stack.push(l);\n        return api as Branch<\n          Base2,\n          Append<readonly [], (typeof leaves)[number]>,\n          I2,\n          ReturnType<typeof mergeSchemas<PS2, P>>\n        >;\n      },\n\n      with<J extends NodeCfg>(cfg: J) {\n        inheritedCfg = { ...inheritedCfg, ...cfg };\n        return api as Branch<Base2, readonly [], Merge<I2, J>, PS2>;\n      },\n\n      // methods (inject current params schema if missing)\n      get<C extends MethodCfg>(cfg: C) {\n        return add('get', cfg);\n      },\n      post<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('post', { ...cfg, feed: false });\n      },\n      put<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('put', { ...cfg, feed: false });\n      },\n      patch<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('patch', { ...cfg, feed: false });\n      },\n      delete<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('delete', { ...cfg, feed: false });\n      },\n\n      done() {\n        return stack;\n      },\n    };\n\n    return api as Branch<Base2, readonly [], I2, PS2>;\n  }\n\n  // Root branch starts with no params schema (PS = undefined)\n  return makeBranch(rootBase, rootInherited, undefined);\n}\n\n/**\n * Merge two readonly tuples (preserves literal tuple information).\n * @param arr1 First tuple.\n * @param arr2 Second tuple.\n * @returns New tuple containing values from both inputs.\n */\nexport const mergeArrays = <T extends readonly any[], S extends readonly any[]>(\n  arr1: T,\n  arr2: S,\n) => {\n  return [...arr1, ...arr2] as [...T, ...S];\n};\n","import { z, ZodTypeAny } from 'zod';\n\n/** Supported HTTP verbs for the routes DSL. */\nexport type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';\n\n/** Declarative description of a multipart upload field. */\nexport type FileField = {\n  /** Form field name used for uploads. */\n  name: string;\n  /** Maximum number of files accepted for this field. */\n  maxCount: number;\n};\n\n/** Configuration that applies to an entire branch of the route tree. */\nexport type NodeCfg = {\n  /** When true, descendant routes require authentication. */\n  authenticated?: boolean;\n};\n\n/** Per-method configuration merged with inherited node config. */\nexport type MethodCfg = NodeCfg & {\n  /** Zod schema describing the request body. */\n  bodySchema?: ZodTypeAny;\n  /** Zod schema describing the query string. */\n  querySchema?: ZodTypeAny;\n  /** Zod schema describing path params (overrides inferred params). */\n  paramsSchema?: ZodTypeAny;\n  /** Zod schema describing the response payload. */\n  outputSchema?: ZodTypeAny;\n  /** Multipart upload definitions for the route. */\n  bodyFiles?: FileField[];\n  /** Marks the route as an infinite feed (enables cursor helpers). */\n  feed?: boolean;\n  /** Optional human-readable description for docs/debugging. */\n  description?: string;\n};\n\n/** Immutable representation of a single HTTP route in the tree. */\nexport type Leaf<M extends HttpMethod, P extends string, C extends MethodCfg> = {\n  /** Lowercase HTTP method (get/post/...). */\n  readonly method: M;\n  /** Concrete path for the route (e.g. `/v1/users/:userId`). */\n  readonly path: P;\n  /** Readonly snapshot of route configuration. */\n  readonly cfg: Readonly<C>;\n};\n\n/** Convenience union covering all generated leaves. */\nexport type AnyLeaf = Leaf<HttpMethod, string, MethodCfg>;\n\n/** Merge two object types while keeping nice IntelliSense output. */\nexport type Merge<A, B> = Prettify<Omit<A, keyof B> & B>;\n\n/** Append a new element to a readonly tuple type. */\nexport type Append<T extends readonly unknown[], X> = [...T, X];\n\n/** Concatenate two readonly tuple types. */\nexport type MergeArray<A extends readonly unknown[], B extends readonly unknown[]> = [\n  ...A,\n  ...B,\n];\n\n// helpers (optional)\ntype SegmentParams<S extends string> = S extends `:${infer P}` ? P : never;\ntype Split<S extends string> = S extends ''\n  ? []\n  : S extends `${infer A}/${infer B}`\n    ? [A, ...Split<B>]\n    : [S];\ntype ExtractParamNames<Path extends string> = SegmentParams<Split<Path>[number]>;\n\n/** Derive a params object type from a literal route string. */\nexport type ExtractParamsFromPath<Path extends string> =\n  ExtractParamNames<Path> extends never ? never : Record<ExtractParamNames<Path>, string | number>;\n\n/**\n * Interpolate `:params` in a path using the given values.\n * @param path Literal route string containing `:param` segments.\n * @param params Object of parameter values to interpolate.\n * @returns Path string with parameters substituted.\n */\nexport function compilePath<Path extends string>(path: Path, params: ExtractParamsFromPath<Path>) {\n  if (!params) return path;\n  return path.replace(/:([A-Za-z0-9_]+)/g, (_, k) => {\n    const v = (params as any)[k];\n    if (v === undefined || v === null) throw new Error(`Missing param :${k}`);\n    return String(v);\n  });\n}\n\n/**\n * Build a deterministic cache key for the given leaf.\n * The key matches the shape consumed by React Query helpers.\n * @param args.leaf Leaf describing the endpoint.\n * @param args.params Optional params used to build the path.\n * @param args.query Optional query payload.\n * @returns Tuple suitable for React Query cache keys.\n */\nexport function buildCacheKey<L extends AnyLeaf>(args: {\n  leaf: L;\n  params?: ExtractParamsFromPath<L['path']>;\n  query?: InferQuery<L>;\n}) {\n  let p = args.leaf.path;\n  if (args.params) {\n    p = compilePath<L['path']>(p, args.params);\n  }\n  return [args.leaf.method, ...p.split('/').filter(Boolean), args.query ?? {}] as const;\n}\n\n/** Infer params either from the explicit params schema or from the path literal. */\nexport type InferParams<L extends AnyLeaf> = L['cfg']['paramsSchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['paramsSchema']>\n  : ExtractParamsFromPath<L['path']>;\n\n/** Infer query shape from a Zod schema when present. */\nexport type InferQuery<L extends AnyLeaf> = L['cfg']['querySchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['querySchema']>\n  : never;\n\n/** Infer request body shape from a Zod schema when present. */\nexport type InferBody<L extends AnyLeaf> = L['cfg']['bodySchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['bodySchema']>\n  : never;\n\n/** Infer handler output shape from a Zod schema. Defaults to unknown. */\nexport type InferOutput<L extends AnyLeaf> = L['cfg']['outputSchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['outputSchema']>\n  : unknown;\n\n/** Render a type as if it were a simple object literal. */\nexport type Prettify<T> = { [K in keyof T]: T[K] } & {};\n","import { AnyLeaf, HttpMethod, Prettify } from './routesV3.core';\n\n/** Build the key type for a leaf — distributive so method/path stay paired. */\nexport type KeyOf<L extends AnyLeaf> = L extends AnyLeaf\n  ? `${Uppercase<L['method']>} ${L['path']}`\n  : never;\n\n// From a tuple of leaves, get the union of keys (pairwise, no cartesian blow-up)\ntype KeysOf<Leaves extends readonly AnyLeaf[]> = KeyOf<Leaves[number]>;\n\n// Parse method & path out of a key\ntype MethodFromKey<K extends string> = K extends `${infer M} ${string}` ? Lowercase<M> : never;\ntype PathFromKey<K extends string> = K extends `${string} ${infer P}` ? P : never;\n\n// Given Leaves and a Key, pick the exact leaf that matches method+path\ntype LeafForKey<Leaves extends readonly AnyLeaf[], K extends string> = Extract<\n  Leaves[number],\n  { method: MethodFromKey<K> & HttpMethod; path: PathFromKey<K> }\n>;\n\n/**\n * Freeze a leaf tuple into a registry with typed key lookups.\n * @param leaves Readonly tuple of leaves produced by the builder DSL.\n * @returns Registry containing the leaves array and a `byKey` lookup map.\n */\nexport function finalize<const L extends readonly AnyLeaf[]>(leaves: L) {\n  type Keys = KeysOf<L>;\n  type MapByKey = { [K in Keys]: Prettify<LeafForKey<L, K>> };\n\n  const byKey = Object.fromEntries(\n    leaves.map((l) => [`${l.method.toUpperCase()} ${l.path}`, l] as const),\n  ) as unknown as MapByKey;\n\n  const log = (logger: { system: (...args: unknown[]) => void }) => {\n    logger.system('Finalized routes:');\n    (Object.keys(byKey) as Keys[]).forEach((k) => {\n      const leaf = byKey[k];\n      logger.system(`- ${k} (auth: ${leaf.cfg.authenticated ? 'yes' : 'no'})`);\n    });\n  };\n\n  return { all: leaves, byKey, log };\n}\n\n/** Nominal type alias for a finalized registry. */\nexport type Registry<R extends ReturnType<typeof finalize>> = R;\n\ntype FilterRoute<\n  T extends readonly AnyLeaf[],\n  F extends string,\n  Acc extends readonly AnyLeaf[] = [],\n> = T extends readonly [infer First extends AnyLeaf, ...infer Rest extends AnyLeaf[]]\n  ? First extends { path: `${string}${F}${string}` }\n    ? FilterRoute<Rest, F, [...Acc, First]>\n    : FilterRoute<Rest, F, Acc>\n  : Acc;\n\ntype UpperCase<S extends string> = S extends `${infer First}${infer Rest}`\n  ? `${Uppercase<First>}${UpperCase<Rest>}`\n  : S;\n\ntype Routes<T extends readonly AnyLeaf[], F extends string> = FilterRoute<T, F>;\ntype ByKey<\n  T extends readonly AnyLeaf[],\n  Acc extends Record<string, AnyLeaf> = {},\n> = T extends readonly [infer First extends AnyLeaf, ...infer Rest extends AnyLeaf[]]\n  ? ByKey<Rest, Acc & { [K in `${UpperCase<First['method']>} ${First['path']}`]: First }>\n  : Acc;\n\n/**\n * Convenience helper for extracting a subset of routes by path fragment.\n * @param T Tuple of leaves produced by the DSL.\n * @param F String fragment to match against the route path.\n */\nexport type SubsetRoutes<T extends readonly AnyLeaf[], F extends string> = {\n  byKey: ByKey<Routes<T, F>>;\n  all: Routes<T, F>;\n};\n","// routesV3.crud.ts\n// -----------------------------------------------------------------------------\n// Add a first-class .crud() helper to the routesV3 DSL, without touching the\n// core builder. This file:\n//   1) Declares types + module augmentation to extend Branch<...> with .crud\n//   2) Provides a runtime decorator `withCrud(...)` that installs the method\n//   3) Exports a convenience `resourceWithCrud(...)` wrapper (optional)\n// -----------------------------------------------------------------------------\n\nimport { z, type ZodTypeAny } from 'zod';\nimport {\n  resource as baseResource,\n  type Branch as _Branch, // import type so we can augment it\n} from '../core/routesV3.builder';\nimport { type AnyLeaf, type Leaf, type NodeCfg } from '../core/routesV3.core';\n\n// -----------------------------------------------------------------------------\n// Small utilities (runtime + types)\n// -----------------------------------------------------------------------------\n\n/** Default cursor pagination used by list (GET collection). */\nexport const CrudDefaultPagination = z.object({\n  limit: z.coerce.number().min(1).max(100).default(20),\n  cursor: z.string().optional(),\n});\n\n/**\n * Merge two Zod schemas at runtime; matches the typing pattern used in builder.\n * @param a Existing params schema inherited from parent branches.\n * @param b Schema introduced at the current branch.\n * @returns Intersection of schemas when both exist, otherwise whichever is defined.\n */\nexport function mergeSchemas<A extends ZodTypeAny | undefined, B extends ZodTypeAny | undefined>(\n  a: A,\n  b: B,\n): A extends ZodTypeAny ? (B extends ZodTypeAny ? ReturnType<typeof z.intersection<A, B>> : A) : B {\n  if (a && b) return z.intersection(a as any, b as any) as any;\n  return (a ?? b) as any;\n}\n\n/** Build { [Name]: S } Zod object at the type-level. */\nexport type ParamSchema<Name extends string, S extends ZodTypeAny> = z.ZodObject<{\n  [K in Name]: S;\n}>;\n\n/** Inject active params schema into a leaf cfg (to match your Leaf typing). */\ntype WithParams<I, P> = P extends ZodTypeAny ? Omit<I, 'paramsSchema'> & { paramsSchema: P } : I;\n\n/** Resolve boolean flag: default D unless explicitly false. */\ntype Flag<E, D extends boolean> = E extends false ? false : D;\n\n// -----------------------------------------------------------------------------\n// CRUD config (few knobs, with DX comments)\n// -----------------------------------------------------------------------------\n\n/** Toggle individual CRUD methods; defaults enable all (create/update require body). */\nexport type CrudEnable = {\n  /** GET /collection (feed). Defaults to true. */ list?: boolean;\n  /** POST /collection. Defaults to true if `create` provided. */ create?: boolean;\n  /** GET /collection/:id. Defaults to true. */ read?: boolean;\n  /** PATCH /collection/:id. Defaults to true if `update` provided. */ update?: boolean;\n  /** DELETE /collection/:id. Defaults to true. */ remove?: boolean;\n};\n\n/** Collection GET config. */\nexport type CrudListCfg = {\n  /** Query schema (defaults to cursor pagination). */\n  querySchema?: ZodTypeAny;\n  /** Output schema (defaults to { items: Item[], nextCursor? }). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description string. */\n  description?: string;\n};\n\n/** Collection POST config. */\nexport type CrudCreateCfg = {\n  /** Body schema for creating an item. */\n  bodySchema: ZodTypeAny;\n  /** Output schema (defaults to itemOutputSchema). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/** Item GET config. */\nexport type CrudReadCfg = {\n  /** Output schema (defaults to itemOutputSchema). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/** Item PATCH config. */\nexport type CrudUpdateCfg = {\n  /** Body schema for partial updates. */\n  bodySchema: ZodTypeAny;\n  /** Output schema (defaults to itemOutputSchema). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/** Item DELETE config. */\nexport type CrudRemoveCfg = {\n  /** Output schema (defaults to { ok: true }). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/**\n * CRUD config for `.crud(\"resource\", cfg, extras?)`.\n *\n * It synthesizes `:[resourceName]Id` as the param key and uses `paramSchema` for the value.\n * Prefer passing a **value schema** (e.g. `z.string().uuid()`).\n * As a convenience, a ZodObject of shape `{ [resourceName]Id: schema }` is accepted at runtime too.\n */\nexport type CrudCfg<Name extends string = string> = {\n  /**\n   * Zod schema for the ID *value* (e.g. `z.string().uuid()`).\n   * The parameter key is always `:${name}Id`.\n   * (If you pass `z.object({ [name]Id: ... })`, it's accepted at runtime.)\n   */\n  paramSchema: ZodTypeAny;\n\n  /**\n   * The single-item output shape used by read/create/update by default.\n   * List defaults to `{ items: z.array(itemOutputSchema), nextCursor? }`.\n   */\n  itemOutputSchema: ZodTypeAny;\n\n  /** Per-method toggles (all enabled by default; create/update require bodies). */\n  enable?: CrudEnable;\n\n  /** GET /collection configuration. */ list?: CrudListCfg;\n  /** POST /collection configuration (enables create). */ create?: CrudCreateCfg;\n  /** GET /collection/:id configuration. */ read?: CrudReadCfg;\n  /** PATCH /collection/:id configuration (enables update). */ update?: CrudUpdateCfg;\n  /** DELETE /collection/:id configuration. */ remove?: CrudRemoveCfg;\n};\n\n// -----------------------------------------------------------------------------\n// Type plumbing to expose generated leaves (so finalize().byKey sees them)\n// -----------------------------------------------------------------------------\n\ntype CrudLeavesTuple<\n  Base extends string,\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n  Name extends string,\n  C extends CrudCfg<Name>,\n> = `${Name}Id` extends infer IdName extends string\n  ? ParamSchema<IdName, C['paramSchema']> extends infer IdParamZ extends ZodTypeAny\n    ? [\n        // GET /collection\n        ...(Flag<\n          C['enable'] extends CrudEnable ? C['enable']['list'] : undefined,\n          true\n        > extends true\n          ? [\n              Leaf<\n                'get',\n                `${Base}/${Name}`,\n                WithParams<\n                  Omit<I, never> & {\n                    feed: true;\n                    querySchema: C['list'] extends CrudListCfg\n                      ? C['list']['querySchema']\n                      : typeof CrudDefaultPagination;\n                    outputSchema: C['list'] extends CrudListCfg\n                      ? C['list']['outputSchema'] extends ZodTypeAny\n                        ? C['list']['outputSchema']\n                        : z.ZodObject<{\n                            items: z.ZodArray<C['itemOutputSchema']>;\n                            nextCursor: z.ZodOptional<z.ZodString>;\n                          }>\n                      : z.ZodObject<{\n                          items: z.ZodArray<C['itemOutputSchema']>;\n                          nextCursor: z.ZodOptional<z.ZodString>;\n                        }>;\n                    description?: string;\n                  },\n                  PS\n                >\n              >,\n            ]\n          : []),\n\n        // POST /collection\n        ...((C['create'] extends CrudCreateCfg ? true : false) extends true\n          ? Flag<\n              C['enable'] extends CrudEnable ? C['enable']['create'] : undefined,\n              true\n            > extends true\n            ? [\n                Leaf<\n                  'post',\n                  `${Base}/${Name}`,\n                  WithParams<\n                    Omit<I, never> & {\n                      bodySchema: C['create'] extends CrudCreateCfg\n                        ? C['create']['bodySchema']\n                        : never;\n                      outputSchema: C['create'] extends CrudCreateCfg\n                        ? C['create']['outputSchema'] extends ZodTypeAny\n                          ? C['create']['outputSchema']\n                          : C['itemOutputSchema']\n                        : never;\n                      description?: string;\n                    },\n                    PS\n                  >\n                >,\n              ]\n            : []\n          : []),\n\n        // GET /collection/:id\n        ...(Flag<\n          C['enable'] extends CrudEnable ? C['enable']['read'] : undefined,\n          true\n        > extends true\n          ? [\n              Leaf<\n                'get',\n                `${Base}/${Name}/:${IdName}`,\n                WithParams<\n                  Omit<I, never> & {\n                    outputSchema: C['read'] extends CrudReadCfg\n                      ? C['read']['outputSchema'] extends ZodTypeAny\n                        ? C['read']['outputSchema']\n                        : C['itemOutputSchema']\n                      : C['itemOutputSchema'];\n                    description?: string;\n                  },\n                  ReturnType<typeof mergeSchemas<PS, IdParamZ>>\n                >\n              >,\n            ]\n          : []),\n\n        // PATCH /collection/:id\n        ...((C['update'] extends CrudUpdateCfg ? true : false) extends true\n          ? Flag<\n              C['enable'] extends CrudEnable ? C['enable']['update'] : undefined,\n              true\n            > extends true\n            ? [\n                Leaf<\n                  'patch',\n                  `${Base}/${Name}/:${IdName}`,\n                  WithParams<\n                    Omit<I, never> & {\n                      bodySchema: C['update'] extends CrudUpdateCfg\n                        ? C['update']['bodySchema']\n                        : never;\n                      outputSchema: C['update'] extends CrudUpdateCfg\n                        ? C['update']['outputSchema'] extends ZodTypeAny\n                          ? C['update']['outputSchema']\n                          : C['itemOutputSchema']\n                        : never;\n                      description?: string;\n                    },\n                    ReturnType<typeof mergeSchemas<PS, IdParamZ>>\n                  >\n                >,\n              ]\n            : []\n          : []),\n\n        // DELETE /collection/:id\n        ...(Flag<\n          C['enable'] extends CrudEnable ? C['enable']['remove'] : undefined,\n          true\n        > extends true\n          ? [\n              Leaf<\n                'delete',\n                `${Base}/${Name}/:${IdName}`,\n                WithParams<\n                  Omit<I, never> & {\n                    outputSchema: C['remove'] extends CrudRemoveCfg\n                      ? C['remove']['outputSchema'] extends ZodTypeAny\n                        ? C['remove']['outputSchema']\n                        : z.ZodObject<{ ok: z.ZodLiteral<true> }>\n                      : z.ZodObject<{ ok: z.ZodLiteral<true> }>;\n                    description?: string;\n                  },\n                  ReturnType<typeof mergeSchemas<PS, IdParamZ>>\n                >\n              >,\n            ]\n          : []),\n      ]\n    : never\n  : never;\n\n/** Merge generated leaves + extras into the branch accumulator. */\ntype CrudResultAcc<\n  Base extends string,\n  Acc extends readonly AnyLeaf[],\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n  Name extends string,\n  C extends CrudCfg<Name>,\n  Extras extends readonly AnyLeaf[],\n> = [...Acc, ...CrudLeavesTuple<Base, I, PS, Name, C>, ...Extras];\n\n// -----------------------------------------------------------------------------\n// Module augmentation: add the typed `.crud(...)` to Branch<...>\n// -----------------------------------------------------------------------------\n\ndeclare module './../core/routesV3.builder' {\n  interface Branch<\n    Base extends string,\n    Acc extends readonly AnyLeaf[],\n    I extends NodeCfg,\n    PS extends ZodTypeAny | undefined,\n  > {\n    /**\n     * Generate opinionated CRUD endpoints for a collection at `/.../<name>`\n     * with an item at `/.../<name>/:<name>Id`.\n     *\n     * Creates (subject to `enable` + presence of create/update bodies):\n     * - GET    /<name>                (feed list)\n     * - POST   /<name>                (create)\n     * - GET    /<name>/:<name>Id      (read item)\n     * - PATCH  /<name>/:<name>Id      (update item)\n     * - DELETE /<name>/:<name>Id      (remove item)\n     *\n     * The `extras` callback receives live builders at both collection and item\n     * levels so you can add custom subroutes; their leaves are included in the\n     * returned Branch type.\n     */\n    crud<\n      Name extends string,\n      C extends CrudCfg<Name>,\n      Extras extends readonly AnyLeaf[] = readonly [],\n    >(\n      name: Name,\n      cfg: C,\n      extras?: (ctx: {\n        /** Builder at `/.../<name>` (collection scope). */\n        collection: _Branch<`${Base}/${Name}`, readonly [], I, PS>;\n        /** Builder at `/.../<name>/:<name>Id` (item scope). */\n        item: _Branch<\n          `${Base}/${Name}/:${`${Name}Id`}`,\n          readonly [],\n          I,\n          ReturnType<typeof mergeSchemas<PS, ParamSchema<`${Name}Id`, C['paramSchema']>>>\n        >;\n      }) => Extras,\n    ): _Branch<Base, CrudResultAcc<Base, Acc, I, PS, Name, C, Extras>, I, PS>;\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Runtime: install .crud on any Branch via decorator\n// -----------------------------------------------------------------------------\n\n/**\n * Decorate a Branch instance so `.crud(...)` is available at runtime.\n * Tip: wrap the root: `withCrud(resource('/v1'))`.\n * @param branch Branch returned by `resource(...)`.\n * @returns Same branch with `.crud(...)` installed.\n */\nexport function withCrud<\n  Base extends string,\n  Acc extends readonly AnyLeaf[],\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n>(branch: _Branch<Base, Acc, I, PS>): _Branch<Base, Acc, I, PS> {\n  const b = branch as any;\n  if (typeof b.crud === 'function') return branch;\n\n  b.crud = function <\n    Name extends string,\n    C extends CrudCfg<Name>,\n    Extras extends readonly AnyLeaf[] = readonly [],\n  >(this: any, name: Name, cfg: C, extras?: (ctx: { collection: any; item: any }) => Extras) {\n    // Build inside a sub-branch at `/.../<name>` and harvest its leaves.\n    return this.sub(name, (collection: any) => {\n      const idKey = `${name}Id`;\n\n      // Accept a value schema (preferred); but if a z.object({[name]Id: ...}) is provided, use it.\n      const s = cfg.paramSchema;\n      const isObj =\n        s &&\n        typeof (s as any)._def === 'object' &&\n        (s as any)._def.typeName === 'ZodObject' &&\n        typeof (s as any).shape === 'function';\n\n      const paramObj =\n        isObj && (s as any).shape()[idKey]\n          ? (s as ZodTypeAny)\n          : z.object({ [idKey]: s } as Record<string, ZodTypeAny>);\n\n      const itemOut = cfg.itemOutputSchema;\n      const listOut =\n        cfg.list?.outputSchema ??\n        z.object({\n          items: z.array(itemOut),\n          nextCursor: z.string().optional(),\n        });\n\n      const want = {\n        list: cfg.enable?.list !== false,\n        create: cfg.enable?.create !== false && !!cfg.create?.bodySchema,\n        read: cfg.enable?.read !== false,\n        update: cfg.enable?.update !== false && !!cfg.update?.bodySchema,\n        remove: cfg.enable?.remove !== false,\n      } as const;\n\n      // Collection routes\n      if (want.list) {\n        const c = cfg.list?.authenticated ? collection.with({ authenticated: true }) : collection;\n        c.get({\n          feed: true,\n          querySchema: cfg.list?.querySchema ?? CrudDefaultPagination,\n          outputSchema: listOut,\n          description: cfg.list?.description ?? 'List',\n        });\n      }\n\n      if (want.create) {\n        const c = cfg.create?.authenticated ? collection.with({ authenticated: true }) : collection;\n        c.post({\n          bodySchema: cfg.create!.bodySchema,\n          outputSchema: cfg.create?.outputSchema ?? itemOut,\n          description: cfg.create?.description ?? 'Create',\n        });\n      }\n\n      // Item routes via :<name>Id\n      collection.routeParameter(idKey as any, paramObj as any, (item: any) => {\n        if (want.read) {\n          const i = cfg.read?.authenticated ? item.with({ authenticated: true }) : item;\n          i.get({\n            outputSchema: cfg.read?.outputSchema ?? itemOut,\n            description: cfg.read?.description ?? 'Read',\n          });\n        }\n        if (want.update) {\n          const i = cfg.update?.authenticated ? item.with({ authenticated: true }) : item;\n          i.patch({\n            bodySchema: cfg.update!.bodySchema,\n            outputSchema: cfg.update?.outputSchema ?? itemOut,\n            description: cfg.update?.description ?? 'Update',\n          });\n        }\n        if (want.remove) {\n          const i = cfg.remove?.authenticated ? item.with({ authenticated: true }) : item;\n          i.delete({\n            outputSchema: cfg.remove?.outputSchema ?? z.object({ ok: z.literal(true) }),\n            description: cfg.remove?.description ?? 'Delete',\n          });\n        }\n\n        // Give extras fully-capable builders (decorate so extras can call .crud again)\n        if (extras) extras({ collection: withCrud(collection), item: withCrud(item) });\n\n        return item.done();\n      });\n\n      return collection.done();\n    });\n  };\n\n  return branch;\n}\n\n// -----------------------------------------------------------------------------\n// Optional convenience: re-export a resource() that already has .crud installed\n// -----------------------------------------------------------------------------\n\n/**\n * Drop-in replacement for `resource(...)` that returns a Branch with `.crud()` installed.\n * You can either use this or call `withCrud(resource(...))`.\n * @param base Root path for the resource (e.g. `/v1`).\n * @param inherited Node configuration merged into every leaf.\n * @returns Branch builder that already includes the CRUD helper.\n */\nexport function resourceWithCrud<Base extends string, I extends NodeCfg = {}>(\n  base: Base,\n  inherited: I,\n) {\n  return withCrud(baseResource(base, inherited));\n}\n\n// Re-export the original in case you want both styles from this module\nexport { baseResource as resource };\n"],"mappings":"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","names":["mergeSchemas","import_zod","mergeSchemas"]}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core/routesV3.builder';
+export * from './core/routesV3.core';
+export * from './core/routesV3.finalize';
+export * from './crud/routesV3.crud';

package/dist/index.js

@@ -0,0 +1,216 @@
+// src/core/routesV3.builder.ts
+import { z } from "zod";
+function mergeSchemas(a, b) {
+  if (a && b) return z.intersection(a, b);
+  return a ?? b;
+}
+function resource(base, inherited) {
+  const rootBase = base;
+  const rootInherited = { ...inherited };
+  function makeBranch(base2, inherited2, mergedParamsSchema) {
+    const stack = [];
+    let currentBase = base2;
+    let inheritedCfg = { ...inherited2 };
+    let currentParamsSchema = mergedParamsSchema;
+    function add(method, cfg) {
+      const effectiveParamsSchema = cfg.paramsSchema ?? currentParamsSchema;
+      const fullCfg = effectiveParamsSchema ? { ...inheritedCfg, ...cfg, paramsSchema: effectiveParamsSchema } : { ...inheritedCfg, ...cfg };
+      const leaf = {
+        method,
+        path: currentBase,
+        cfg: fullCfg
+      };
+      stack.push(leaf);
+      return api;
+    }
+    const api = {
+      // compose a plain subpath (optional cfg) with optional builder
+      sub(name, cfgOrBuilder, maybeBuilder) {
+        let cfg;
+        let builder;
+        if (typeof cfgOrBuilder === "function") {
+          builder = cfgOrBuilder;
+        } else {
+          cfg = cfgOrBuilder;
+          builder = maybeBuilder;
+        }
+        const childBase = `${currentBase}/${name}`;
+        const childInherited = { ...inheritedCfg, ...cfg ?? {} };
+        if (builder) {
+          const child = makeBranch(childBase, childInherited, currentParamsSchema);
+          const leaves = builder(child);
+          for (const l of leaves) stack.push(l);
+          return api;
+        } else {
+          currentBase = childBase;
+          inheritedCfg = childInherited;
+          return api;
+        }
+      },
+      // the single param function: name + schema + builder
+      routeParameter(name, paramsSchema, builder) {
+        const childBase = `${currentBase}/:${name}`;
+        const childParams = mergeSchemas(currentParamsSchema, paramsSchema);
+        const child = makeBranch(childBase, inheritedCfg, childParams);
+        const leaves = builder(child);
+        for (const l of leaves) stack.push(l);
+        return api;
+      },
+      with(cfg) {
+        inheritedCfg = { ...inheritedCfg, ...cfg };
+        return api;
+      },
+      // methods (inject current params schema if missing)
+      get(cfg) {
+        return add("get", cfg);
+      },
+      post(cfg) {
+        return add("post", { ...cfg, feed: false });
+      },
+      put(cfg) {
+        return add("put", { ...cfg, feed: false });
+      },
+      patch(cfg) {
+        return add("patch", { ...cfg, feed: false });
+      },
+      delete(cfg) {
+        return add("delete", { ...cfg, feed: false });
+      },
+      done() {
+        return stack;
+      }
+    };
+    return api;
+  }
+  return makeBranch(rootBase, rootInherited, void 0);
+}
+var mergeArrays = (arr1, arr2) => {
+  return [...arr1, ...arr2];
+};
+
+// src/core/routesV3.core.ts
+function compilePath(path, params) {
+  if (!params) return path;
+  return path.replace(/:([A-Za-z0-9_]+)/g, (_, k) => {
+    const v = params[k];
+    if (v === void 0 || v === null) throw new Error(`Missing param :${k}`);
+    return String(v);
+  });
+}
+function buildCacheKey(args) {
+  let p = args.leaf.path;
+  if (args.params) {
+    p = compilePath(p, args.params);
+  }
+  return [args.leaf.method, ...p.split("/").filter(Boolean), args.query ?? {}];
+}
+
+// src/core/routesV3.finalize.ts
+function finalize(leaves) {
+  const byKey = Object.fromEntries(
+    leaves.map((l) => [`${l.method.toUpperCase()} ${l.path}`, l])
+  );
+  const log = (logger) => {
+    logger.system("Finalized routes:");
+    Object.keys(byKey).forEach((k) => {
+      const leaf = byKey[k];
+      logger.system(`- ${k} (auth: ${leaf.cfg.authenticated ? "yes" : "no"})`);
+    });
+  };
+  return { all: leaves, byKey, log };
+}
+
+// src/crud/routesV3.crud.ts
+import { z as z2 } from "zod";
+var CrudDefaultPagination = z2.object({
+  limit: z2.coerce.number().min(1).max(100).default(20),
+  cursor: z2.string().optional()
+});
+function mergeSchemas2(a, b) {
+  if (a && b) return z2.intersection(a, b);
+  return a ?? b;
+}
+function withCrud(branch) {
+  const b = branch;
+  if (typeof b.crud === "function") return branch;
+  b.crud = function(name, cfg, extras) {
+    return this.sub(name, (collection) => {
+      const idKey = `${name}Id`;
+      const s = cfg.paramSchema;
+      const isObj = s && typeof s._def === "object" && s._def.typeName === "ZodObject" && typeof s.shape === "function";
+      const paramObj = isObj && s.shape()[idKey] ? s : z2.object({ [idKey]: s });
+      const itemOut = cfg.itemOutputSchema;
+      const listOut = cfg.list?.outputSchema ?? z2.object({
+        items: z2.array(itemOut),
+        nextCursor: z2.string().optional()
+      });
+      const want = {
+        list: cfg.enable?.list !== false,
+        create: cfg.enable?.create !== false && !!cfg.create?.bodySchema,
+        read: cfg.enable?.read !== false,
+        update: cfg.enable?.update !== false && !!cfg.update?.bodySchema,
+        remove: cfg.enable?.remove !== false
+      };
+      if (want.list) {
+        const c = cfg.list?.authenticated ? collection.with({ authenticated: true }) : collection;
+        c.get({
+          feed: true,
+          querySchema: cfg.list?.querySchema ?? CrudDefaultPagination,
+          outputSchema: listOut,
+          description: cfg.list?.description ?? "List"
+        });
+      }
+      if (want.create) {
+        const c = cfg.create?.authenticated ? collection.with({ authenticated: true }) : collection;
+        c.post({
+          bodySchema: cfg.create.bodySchema,
+          outputSchema: cfg.create?.outputSchema ?? itemOut,
+          description: cfg.create?.description ?? "Create"
+        });
+      }
+      collection.routeParameter(idKey, paramObj, (item) => {
+        if (want.read) {
+          const i = cfg.read?.authenticated ? item.with({ authenticated: true }) : item;
+          i.get({
+            outputSchema: cfg.read?.outputSchema ?? itemOut,
+            description: cfg.read?.description ?? "Read"
+          });
+        }
+        if (want.update) {
+          const i = cfg.update?.authenticated ? item.with({ authenticated: true }) : item;
+          i.patch({
+            bodySchema: cfg.update.bodySchema,
+            outputSchema: cfg.update?.outputSchema ?? itemOut,
+            description: cfg.update?.description ?? "Update"
+          });
+        }
+        if (want.remove) {
+          const i = cfg.remove?.authenticated ? item.with({ authenticated: true }) : item;
+          i.delete({
+            outputSchema: cfg.remove?.outputSchema ?? z2.object({ ok: z2.literal(true) }),
+            description: cfg.remove?.description ?? "Delete"
+          });
+        }
+        if (extras) extras({ collection: withCrud(collection), item: withCrud(item) });
+        return item.done();
+      });
+      return collection.done();
+    });
+  };
+  return branch;
+}
+function resourceWithCrud(base, inherited) {
+  return withCrud(resource(base, inherited));
+}
+export {
+  CrudDefaultPagination,
+  buildCacheKey,
+  compilePath,
+  finalize,
+  mergeArrays,
+  mergeSchemas2 as mergeSchemas,
+  resource,
+  resourceWithCrud,
+  withCrud
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/routesV3.builder.ts","../src/core/routesV3.core.ts","../src/core/routesV3.finalize.ts","../src/crud/routesV3.crud.ts"],"sourcesContent":["import { z } from 'zod';\nimport {\n  AnyLeaf,\n  Append,\n  HttpMethod,\n  Leaf,\n  Merge,\n  MergeArray,\n  MethodCfg,\n  NodeCfg,\n  Prettify,\n} from './routesV3.core';\n\ntype ZodTypeAny = z.ZodTypeAny;\n\n/**\n * Runtime helper that mirrors the typed merge used by the builder.\n * @param a Previously merged params schema inherited from parent segments.\n * @param b Newly introduced params schema.\n * @returns Intersection of schemas when both exist, otherwise whichever is defined.\n */\nfunction mergeSchemas<A extends ZodTypeAny | undefined, B extends ZodTypeAny | undefined>(\n  a: A,\n  b: B,\n): A extends ZodTypeAny ? (B extends ZodTypeAny ? ReturnType<typeof z.intersection<A, B>> : A) : B {\n  if (a && b) return z.intersection(a as any, b as any) as any;\n  return (a ?? b) as any;\n}\n\n/** Builder surface used by `resource(...)` to accumulate leaves. */\nexport interface Branch<\n  Base extends string,\n  Acc extends readonly AnyLeaf[],\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n> {\n  // --- structure ---\n  /**\n   * Enter or define a static child segment.\n   * Optionally accepts extra config and/or a builder to populate nested routes.\n   * @param name Child segment literal (no leading slash).\n   * @param cfg Optional node configuration to merge for descendants.\n   * @param builder Callback to produce leaves for the child branch.\n   */\n  sub<Name extends string, J extends NodeCfg>(\n    name: Name,\n    cfg?: J,\n  ): Branch<`${Base}/${Name}`, Acc, Merge<I, NonNullable<J>>, PS>;\n\n  sub<Name extends string, J extends NodeCfg | undefined, R extends readonly AnyLeaf[]>(\n    name: Name,\n    cfg: J,\n    builder: (r: Branch<`${Base}/${Name}`, readonly [], Merge<I, NonNullable<J>>, PS>) => R,\n  ): Branch<Base, Append<Acc, R[number]>, Merge<I, NonNullable<J>>, PS>;\n\n  sub<Name extends string, R extends readonly AnyLeaf[]>(\n    name: Name,\n    builder: (r: Branch<`${Base}/${Name}`, readonly [], I, PS>) => R,\n  ): Branch<Base, MergeArray<Acc, R>, I, PS>;\n\n  // --- parameterized segment (single signature) ---\n  /**\n   * Introduce a `:param` segment and merge its schema into downstream leaves.\n   * @param name Parameter key (without leading colon).\n   * @param paramsSchema Zod schema for the parameter value.\n   * @param builder Callback that produces leaves beneath the parameterized segment.\n   */\n  routeParameter<Name extends string, P extends ZodTypeAny, R extends readonly AnyLeaf[]>(\n    name: Name,\n    paramsSchema: P,\n    builder: (\n      r: Branch<`${Base}/:${Name}`, readonly [], I, ReturnType<typeof mergeSchemas<PS, P>>>,\n    ) => R,\n  ): Branch<Base, MergeArray<Acc, R>, I, ReturnType<typeof mergeSchemas<PS, P>>>;\n\n  // --- flags inheritance ---\n  /**\n   * Merge additional node configuration that subsequent leaves will inherit.\n   * @param cfg Partial node configuration (e.g. `{ authenticated: true }`).\n   */\n  with<J extends NodeCfg>(cfg: J): Branch<Base, Acc, Merge<I, J>, PS>;\n\n  // --- methods (return Branch to keep chaining) ---\n  /**\n   * Register a GET leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  get<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<\n    Base,\n    Append<Acc, Prettify<Leaf<'get', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>>,\n    I,\n    PS\n  >;\n\n  /**\n   * Register a POST leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  post<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<Base, Append<Acc, Leaf<'post', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>, I, PS>;\n\n  /**\n   * Register a PUT leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  put<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<Base, Append<Acc, Leaf<'put', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>, I, PS>;\n\n  /**\n   * Register a PATCH leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  patch<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<\n    Base,\n    Append<Acc, Leaf<'patch', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>,\n    I,\n    PS\n  >;\n\n  /**\n   * Register a DELETE leaf at the current path.\n   * @param cfg Method configuration (schemas, flags, descriptions, etc).\n   */\n  delete<C extends Omit<MethodCfg, 'paramsSchema'>>(\n    cfg: C,\n  ): Branch<\n    Base,\n    Append<Acc, Leaf<'delete', Base, Merge<Merge<I, C>, { paramsSchema: PS }>>>,\n    I,\n    PS\n  >;\n\n  // --- finalize this subtree ---\n  /**\n   * Finish the branch and return the collected leaves.\n   * @returns Readonly tuple of accumulated leaves.\n   */\n  done(): Readonly<Acc>;\n}\n\n/**\n * Start building a resource at the given base path.\n * @param base Root path for the resource (e.g. `/v1`).\n * @param inherited Optional node configuration applied to all descendants.\n * @returns Root `Branch` instance used to compose the route tree.\n */\nexport function resource<Base extends string, I extends NodeCfg = {}>(\n  base: Base,\n  inherited?: I,\n): Branch<Base, readonly [], I, undefined> {\n  const rootBase = base;\n  const rootInherited: NodeCfg = { ...(inherited as NodeCfg) };\n\n  function makeBranch<Base2 extends string, I2 extends NodeCfg, PS2 extends ZodTypeAny | undefined>(\n    base2: Base2,\n    inherited2: I2,\n    mergedParamsSchema?: PS2,\n  ) {\n    const stack: AnyLeaf[] = [];\n    let currentBase: string = base2;\n    let inheritedCfg: NodeCfg = { ...(inherited2 as NodeCfg) };\n    let currentParamsSchema: PS2 = mergedParamsSchema as PS2;\n\n    function add<M extends HttpMethod, C extends MethodCfg>(method: M, cfg: C) {\n      // If the method didn’t provide a paramsSchema, inject the active merged one.\n      const effectiveParamsSchema = (cfg.paramsSchema ?? currentParamsSchema) as PS2 | undefined;\n      const fullCfg = (\n        effectiveParamsSchema\n          ? { ...inheritedCfg, ...cfg, paramsSchema: effectiveParamsSchema }\n          : { ...inheritedCfg, ...cfg }\n      ) as Merge<I2, C>;\n\n      const leaf = {\n        method,\n        path: currentBase as Base2,\n        cfg: fullCfg,\n      } as const;\n\n      stack.push(leaf as unknown as AnyLeaf);\n\n      // Return same runtime obj, but with Acc including this new leaf\n      return api as unknown as Branch<Base2, Append<readonly [], typeof leaf>, I2, PS2>;\n    }\n\n    const api: any = {\n      // compose a plain subpath (optional cfg) with optional builder\n      sub<Name extends string, J extends NodeCfg | undefined = undefined>(\n        name: Name,\n        cfgOrBuilder?: J | ((r: any) => readonly AnyLeaf[]),\n        maybeBuilder?: (r: any) => readonly AnyLeaf[],\n      ) {\n        let cfg: NodeCfg | undefined;\n        let builder: ((r: any) => readonly AnyLeaf[]) | undefined;\n\n        if (typeof cfgOrBuilder === 'function') {\n          builder = cfgOrBuilder as any;\n        } else {\n          cfg = cfgOrBuilder as NodeCfg | undefined;\n          builder = maybeBuilder;\n        }\n\n        const childBase = `${currentBase}/${name}` as const;\n        const childInherited = { ...inheritedCfg, ...(cfg ?? {}) } as Merge<I2, NonNullable<J>>;\n\n        if (builder) {\n          // params schema PS2 flows through unchanged on plain sub\n          const child = makeBranch(childBase, childInherited, currentParamsSchema);\n          const leaves = builder(child) as readonly AnyLeaf[];\n          for (const l of leaves) stack.push(l);\n          return api as Branch<\n            Base2,\n            Append<readonly [], (typeof leaves)[number]>,\n            typeof childInherited,\n            PS2\n          >;\n        } else {\n          currentBase = childBase;\n          inheritedCfg = childInherited;\n          return api as Branch<`${Base2}/${Name}`, readonly [], typeof childInherited, PS2>;\n        }\n      },\n\n      // the single param function: name + schema + builder\n      routeParameter<Name extends string, P extends ZodTypeAny, R extends readonly AnyLeaf[]>(\n        name: Name,\n        paramsSchema: P,\n        builder: (\n          r: Branch<`${Base2}/:${Name}`, readonly [], I2, ReturnType<typeof mergeSchemas<PS2, P>>>,\n        ) => R,\n      ) {\n        const childBase = `${currentBase}/:${name}` as const;\n        // Merge existing PS2 with P to create the child’s active params schema\n        const childParams = mergeSchemas(currentParamsSchema, paramsSchema);\n        const child = makeBranch(childBase, inheritedCfg as I2, childParams);\n        const leaves = builder(child) as readonly AnyLeaf[];\n        for (const l of leaves) stack.push(l);\n        return api as Branch<\n          Base2,\n          Append<readonly [], (typeof leaves)[number]>,\n          I2,\n          ReturnType<typeof mergeSchemas<PS2, P>>\n        >;\n      },\n\n      with<J extends NodeCfg>(cfg: J) {\n        inheritedCfg = { ...inheritedCfg, ...cfg };\n        return api as Branch<Base2, readonly [], Merge<I2, J>, PS2>;\n      },\n\n      // methods (inject current params schema if missing)\n      get<C extends MethodCfg>(cfg: C) {\n        return add('get', cfg);\n      },\n      post<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('post', { ...cfg, feed: false });\n      },\n      put<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('put', { ...cfg, feed: false });\n      },\n      patch<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('patch', { ...cfg, feed: false });\n      },\n      delete<C extends Omit<MethodCfg, 'feed'>>(cfg: C) {\n        return add('delete', { ...cfg, feed: false });\n      },\n\n      done() {\n        return stack;\n      },\n    };\n\n    return api as Branch<Base2, readonly [], I2, PS2>;\n  }\n\n  // Root branch starts with no params schema (PS = undefined)\n  return makeBranch(rootBase, rootInherited, undefined);\n}\n\n/**\n * Merge two readonly tuples (preserves literal tuple information).\n * @param arr1 First tuple.\n * @param arr2 Second tuple.\n * @returns New tuple containing values from both inputs.\n */\nexport const mergeArrays = <T extends readonly any[], S extends readonly any[]>(\n  arr1: T,\n  arr2: S,\n) => {\n  return [...arr1, ...arr2] as [...T, ...S];\n};\n","import { z, ZodTypeAny } from 'zod';\n\n/** Supported HTTP verbs for the routes DSL. */\nexport type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';\n\n/** Declarative description of a multipart upload field. */\nexport type FileField = {\n  /** Form field name used for uploads. */\n  name: string;\n  /** Maximum number of files accepted for this field. */\n  maxCount: number;\n};\n\n/** Configuration that applies to an entire branch of the route tree. */\nexport type NodeCfg = {\n  /** When true, descendant routes require authentication. */\n  authenticated?: boolean;\n};\n\n/** Per-method configuration merged with inherited node config. */\nexport type MethodCfg = NodeCfg & {\n  /** Zod schema describing the request body. */\n  bodySchema?: ZodTypeAny;\n  /** Zod schema describing the query string. */\n  querySchema?: ZodTypeAny;\n  /** Zod schema describing path params (overrides inferred params). */\n  paramsSchema?: ZodTypeAny;\n  /** Zod schema describing the response payload. */\n  outputSchema?: ZodTypeAny;\n  /** Multipart upload definitions for the route. */\n  bodyFiles?: FileField[];\n  /** Marks the route as an infinite feed (enables cursor helpers). */\n  feed?: boolean;\n  /** Optional human-readable description for docs/debugging. */\n  description?: string;\n};\n\n/** Immutable representation of a single HTTP route in the tree. */\nexport type Leaf<M extends HttpMethod, P extends string, C extends MethodCfg> = {\n  /** Lowercase HTTP method (get/post/...). */\n  readonly method: M;\n  /** Concrete path for the route (e.g. `/v1/users/:userId`). */\n  readonly path: P;\n  /** Readonly snapshot of route configuration. */\n  readonly cfg: Readonly<C>;\n};\n\n/** Convenience union covering all generated leaves. */\nexport type AnyLeaf = Leaf<HttpMethod, string, MethodCfg>;\n\n/** Merge two object types while keeping nice IntelliSense output. */\nexport type Merge<A, B> = Prettify<Omit<A, keyof B> & B>;\n\n/** Append a new element to a readonly tuple type. */\nexport type Append<T extends readonly unknown[], X> = [...T, X];\n\n/** Concatenate two readonly tuple types. */\nexport type MergeArray<A extends readonly unknown[], B extends readonly unknown[]> = [\n  ...A,\n  ...B,\n];\n\n// helpers (optional)\ntype SegmentParams<S extends string> = S extends `:${infer P}` ? P : never;\ntype Split<S extends string> = S extends ''\n  ? []\n  : S extends `${infer A}/${infer B}`\n    ? [A, ...Split<B>]\n    : [S];\ntype ExtractParamNames<Path extends string> = SegmentParams<Split<Path>[number]>;\n\n/** Derive a params object type from a literal route string. */\nexport type ExtractParamsFromPath<Path extends string> =\n  ExtractParamNames<Path> extends never ? never : Record<ExtractParamNames<Path>, string | number>;\n\n/**\n * Interpolate `:params` in a path using the given values.\n * @param path Literal route string containing `:param` segments.\n * @param params Object of parameter values to interpolate.\n * @returns Path string with parameters substituted.\n */\nexport function compilePath<Path extends string>(path: Path, params: ExtractParamsFromPath<Path>) {\n  if (!params) return path;\n  return path.replace(/:([A-Za-z0-9_]+)/g, (_, k) => {\n    const v = (params as any)[k];\n    if (v === undefined || v === null) throw new Error(`Missing param :${k}`);\n    return String(v);\n  });\n}\n\n/**\n * Build a deterministic cache key for the given leaf.\n * The key matches the shape consumed by React Query helpers.\n * @param args.leaf Leaf describing the endpoint.\n * @param args.params Optional params used to build the path.\n * @param args.query Optional query payload.\n * @returns Tuple suitable for React Query cache keys.\n */\nexport function buildCacheKey<L extends AnyLeaf>(args: {\n  leaf: L;\n  params?: ExtractParamsFromPath<L['path']>;\n  query?: InferQuery<L>;\n}) {\n  let p = args.leaf.path;\n  if (args.params) {\n    p = compilePath<L['path']>(p, args.params);\n  }\n  return [args.leaf.method, ...p.split('/').filter(Boolean), args.query ?? {}] as const;\n}\n\n/** Infer params either from the explicit params schema or from the path literal. */\nexport type InferParams<L extends AnyLeaf> = L['cfg']['paramsSchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['paramsSchema']>\n  : ExtractParamsFromPath<L['path']>;\n\n/** Infer query shape from a Zod schema when present. */\nexport type InferQuery<L extends AnyLeaf> = L['cfg']['querySchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['querySchema']>\n  : never;\n\n/** Infer request body shape from a Zod schema when present. */\nexport type InferBody<L extends AnyLeaf> = L['cfg']['bodySchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['bodySchema']>\n  : never;\n\n/** Infer handler output shape from a Zod schema. Defaults to unknown. */\nexport type InferOutput<L extends AnyLeaf> = L['cfg']['outputSchema'] extends ZodTypeAny\n  ? z.infer<L['cfg']['outputSchema']>\n  : unknown;\n\n/** Render a type as if it were a simple object literal. */\nexport type Prettify<T> = { [K in keyof T]: T[K] } & {};\n","import { AnyLeaf, HttpMethod, Prettify } from './routesV3.core';\n\n/** Build the key type for a leaf — distributive so method/path stay paired. */\nexport type KeyOf<L extends AnyLeaf> = L extends AnyLeaf\n  ? `${Uppercase<L['method']>} ${L['path']}`\n  : never;\n\n// From a tuple of leaves, get the union of keys (pairwise, no cartesian blow-up)\ntype KeysOf<Leaves extends readonly AnyLeaf[]> = KeyOf<Leaves[number]>;\n\n// Parse method & path out of a key\ntype MethodFromKey<K extends string> = K extends `${infer M} ${string}` ? Lowercase<M> : never;\ntype PathFromKey<K extends string> = K extends `${string} ${infer P}` ? P : never;\n\n// Given Leaves and a Key, pick the exact leaf that matches method+path\ntype LeafForKey<Leaves extends readonly AnyLeaf[], K extends string> = Extract<\n  Leaves[number],\n  { method: MethodFromKey<K> & HttpMethod; path: PathFromKey<K> }\n>;\n\n/**\n * Freeze a leaf tuple into a registry with typed key lookups.\n * @param leaves Readonly tuple of leaves produced by the builder DSL.\n * @returns Registry containing the leaves array and a `byKey` lookup map.\n */\nexport function finalize<const L extends readonly AnyLeaf[]>(leaves: L) {\n  type Keys = KeysOf<L>;\n  type MapByKey = { [K in Keys]: Prettify<LeafForKey<L, K>> };\n\n  const byKey = Object.fromEntries(\n    leaves.map((l) => [`${l.method.toUpperCase()} ${l.path}`, l] as const),\n  ) as unknown as MapByKey;\n\n  const log = (logger: { system: (...args: unknown[]) => void }) => {\n    logger.system('Finalized routes:');\n    (Object.keys(byKey) as Keys[]).forEach((k) => {\n      const leaf = byKey[k];\n      logger.system(`- ${k} (auth: ${leaf.cfg.authenticated ? 'yes' : 'no'})`);\n    });\n  };\n\n  return { all: leaves, byKey, log };\n}\n\n/** Nominal type alias for a finalized registry. */\nexport type Registry<R extends ReturnType<typeof finalize>> = R;\n\ntype FilterRoute<\n  T extends readonly AnyLeaf[],\n  F extends string,\n  Acc extends readonly AnyLeaf[] = [],\n> = T extends readonly [infer First extends AnyLeaf, ...infer Rest extends AnyLeaf[]]\n  ? First extends { path: `${string}${F}${string}` }\n    ? FilterRoute<Rest, F, [...Acc, First]>\n    : FilterRoute<Rest, F, Acc>\n  : Acc;\n\ntype UpperCase<S extends string> = S extends `${infer First}${infer Rest}`\n  ? `${Uppercase<First>}${UpperCase<Rest>}`\n  : S;\n\ntype Routes<T extends readonly AnyLeaf[], F extends string> = FilterRoute<T, F>;\ntype ByKey<\n  T extends readonly AnyLeaf[],\n  Acc extends Record<string, AnyLeaf> = {},\n> = T extends readonly [infer First extends AnyLeaf, ...infer Rest extends AnyLeaf[]]\n  ? ByKey<Rest, Acc & { [K in `${UpperCase<First['method']>} ${First['path']}`]: First }>\n  : Acc;\n\n/**\n * Convenience helper for extracting a subset of routes by path fragment.\n * @param T Tuple of leaves produced by the DSL.\n * @param F String fragment to match against the route path.\n */\nexport type SubsetRoutes<T extends readonly AnyLeaf[], F extends string> = {\n  byKey: ByKey<Routes<T, F>>;\n  all: Routes<T, F>;\n};\n","// routesV3.crud.ts\n// -----------------------------------------------------------------------------\n// Add a first-class .crud() helper to the routesV3 DSL, without touching the\n// core builder. This file:\n//   1) Declares types + module augmentation to extend Branch<...> with .crud\n//   2) Provides a runtime decorator `withCrud(...)` that installs the method\n//   3) Exports a convenience `resourceWithCrud(...)` wrapper (optional)\n// -----------------------------------------------------------------------------\n\nimport { z, type ZodTypeAny } from 'zod';\nimport {\n  resource as baseResource,\n  type Branch as _Branch, // import type so we can augment it\n} from '../core/routesV3.builder';\nimport { type AnyLeaf, type Leaf, type NodeCfg } from '../core/routesV3.core';\n\n// -----------------------------------------------------------------------------\n// Small utilities (runtime + types)\n// -----------------------------------------------------------------------------\n\n/** Default cursor pagination used by list (GET collection). */\nexport const CrudDefaultPagination = z.object({\n  limit: z.coerce.number().min(1).max(100).default(20),\n  cursor: z.string().optional(),\n});\n\n/**\n * Merge two Zod schemas at runtime; matches the typing pattern used in builder.\n * @param a Existing params schema inherited from parent branches.\n * @param b Schema introduced at the current branch.\n * @returns Intersection of schemas when both exist, otherwise whichever is defined.\n */\nexport function mergeSchemas<A extends ZodTypeAny | undefined, B extends ZodTypeAny | undefined>(\n  a: A,\n  b: B,\n): A extends ZodTypeAny ? (B extends ZodTypeAny ? ReturnType<typeof z.intersection<A, B>> : A) : B {\n  if (a && b) return z.intersection(a as any, b as any) as any;\n  return (a ?? b) as any;\n}\n\n/** Build { [Name]: S } Zod object at the type-level. */\nexport type ParamSchema<Name extends string, S extends ZodTypeAny> = z.ZodObject<{\n  [K in Name]: S;\n}>;\n\n/** Inject active params schema into a leaf cfg (to match your Leaf typing). */\ntype WithParams<I, P> = P extends ZodTypeAny ? Omit<I, 'paramsSchema'> & { paramsSchema: P } : I;\n\n/** Resolve boolean flag: default D unless explicitly false. */\ntype Flag<E, D extends boolean> = E extends false ? false : D;\n\n// -----------------------------------------------------------------------------\n// CRUD config (few knobs, with DX comments)\n// -----------------------------------------------------------------------------\n\n/** Toggle individual CRUD methods; defaults enable all (create/update require body). */\nexport type CrudEnable = {\n  /** GET /collection (feed). Defaults to true. */ list?: boolean;\n  /** POST /collection. Defaults to true if `create` provided. */ create?: boolean;\n  /** GET /collection/:id. Defaults to true. */ read?: boolean;\n  /** PATCH /collection/:id. Defaults to true if `update` provided. */ update?: boolean;\n  /** DELETE /collection/:id. Defaults to true. */ remove?: boolean;\n};\n\n/** Collection GET config. */\nexport type CrudListCfg = {\n  /** Query schema (defaults to cursor pagination). */\n  querySchema?: ZodTypeAny;\n  /** Output schema (defaults to { items: Item[], nextCursor? }). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description string. */\n  description?: string;\n};\n\n/** Collection POST config. */\nexport type CrudCreateCfg = {\n  /** Body schema for creating an item. */\n  bodySchema: ZodTypeAny;\n  /** Output schema (defaults to itemOutputSchema). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/** Item GET config. */\nexport type CrudReadCfg = {\n  /** Output schema (defaults to itemOutputSchema). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/** Item PATCH config. */\nexport type CrudUpdateCfg = {\n  /** Body schema for partial updates. */\n  bodySchema: ZodTypeAny;\n  /** Output schema (defaults to itemOutputSchema). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/** Item DELETE config. */\nexport type CrudRemoveCfg = {\n  /** Output schema (defaults to { ok: true }). */\n  outputSchema?: ZodTypeAny;\n  /** Require auth for this leaf (put on node via `.with({ authenticated:true })`). */\n  authenticated?: boolean;\n  /** Optional description. */\n  description?: string;\n};\n\n/**\n * CRUD config for `.crud(\"resource\", cfg, extras?)`.\n *\n * It synthesizes `:[resourceName]Id` as the param key and uses `paramSchema` for the value.\n * Prefer passing a **value schema** (e.g. `z.string().uuid()`).\n * As a convenience, a ZodObject of shape `{ [resourceName]Id: schema }` is accepted at runtime too.\n */\nexport type CrudCfg<Name extends string = string> = {\n  /**\n   * Zod schema for the ID *value* (e.g. `z.string().uuid()`).\n   * The parameter key is always `:${name}Id`.\n   * (If you pass `z.object({ [name]Id: ... })`, it's accepted at runtime.)\n   */\n  paramSchema: ZodTypeAny;\n\n  /**\n   * The single-item output shape used by read/create/update by default.\n   * List defaults to `{ items: z.array(itemOutputSchema), nextCursor? }`.\n   */\n  itemOutputSchema: ZodTypeAny;\n\n  /** Per-method toggles (all enabled by default; create/update require bodies). */\n  enable?: CrudEnable;\n\n  /** GET /collection configuration. */ list?: CrudListCfg;\n  /** POST /collection configuration (enables create). */ create?: CrudCreateCfg;\n  /** GET /collection/:id configuration. */ read?: CrudReadCfg;\n  /** PATCH /collection/:id configuration (enables update). */ update?: CrudUpdateCfg;\n  /** DELETE /collection/:id configuration. */ remove?: CrudRemoveCfg;\n};\n\n// -----------------------------------------------------------------------------\n// Type plumbing to expose generated leaves (so finalize().byKey sees them)\n// -----------------------------------------------------------------------------\n\ntype CrudLeavesTuple<\n  Base extends string,\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n  Name extends string,\n  C extends CrudCfg<Name>,\n> = `${Name}Id` extends infer IdName extends string\n  ? ParamSchema<IdName, C['paramSchema']> extends infer IdParamZ extends ZodTypeAny\n    ? [\n        // GET /collection\n        ...(Flag<\n          C['enable'] extends CrudEnable ? C['enable']['list'] : undefined,\n          true\n        > extends true\n          ? [\n              Leaf<\n                'get',\n                `${Base}/${Name}`,\n                WithParams<\n                  Omit<I, never> & {\n                    feed: true;\n                    querySchema: C['list'] extends CrudListCfg\n                      ? C['list']['querySchema']\n                      : typeof CrudDefaultPagination;\n                    outputSchema: C['list'] extends CrudListCfg\n                      ? C['list']['outputSchema'] extends ZodTypeAny\n                        ? C['list']['outputSchema']\n                        : z.ZodObject<{\n                            items: z.ZodArray<C['itemOutputSchema']>;\n                            nextCursor: z.ZodOptional<z.ZodString>;\n                          }>\n                      : z.ZodObject<{\n                          items: z.ZodArray<C['itemOutputSchema']>;\n                          nextCursor: z.ZodOptional<z.ZodString>;\n                        }>;\n                    description?: string;\n                  },\n                  PS\n                >\n              >,\n            ]\n          : []),\n\n        // POST /collection\n        ...((C['create'] extends CrudCreateCfg ? true : false) extends true\n          ? Flag<\n              C['enable'] extends CrudEnable ? C['enable']['create'] : undefined,\n              true\n            > extends true\n            ? [\n                Leaf<\n                  'post',\n                  `${Base}/${Name}`,\n                  WithParams<\n                    Omit<I, never> & {\n                      bodySchema: C['create'] extends CrudCreateCfg\n                        ? C['create']['bodySchema']\n                        : never;\n                      outputSchema: C['create'] extends CrudCreateCfg\n                        ? C['create']['outputSchema'] extends ZodTypeAny\n                          ? C['create']['outputSchema']\n                          : C['itemOutputSchema']\n                        : never;\n                      description?: string;\n                    },\n                    PS\n                  >\n                >,\n              ]\n            : []\n          : []),\n\n        // GET /collection/:id\n        ...(Flag<\n          C['enable'] extends CrudEnable ? C['enable']['read'] : undefined,\n          true\n        > extends true\n          ? [\n              Leaf<\n                'get',\n                `${Base}/${Name}/:${IdName}`,\n                WithParams<\n                  Omit<I, never> & {\n                    outputSchema: C['read'] extends CrudReadCfg\n                      ? C['read']['outputSchema'] extends ZodTypeAny\n                        ? C['read']['outputSchema']\n                        : C['itemOutputSchema']\n                      : C['itemOutputSchema'];\n                    description?: string;\n                  },\n                  ReturnType<typeof mergeSchemas<PS, IdParamZ>>\n                >\n              >,\n            ]\n          : []),\n\n        // PATCH /collection/:id\n        ...((C['update'] extends CrudUpdateCfg ? true : false) extends true\n          ? Flag<\n              C['enable'] extends CrudEnable ? C['enable']['update'] : undefined,\n              true\n            > extends true\n            ? [\n                Leaf<\n                  'patch',\n                  `${Base}/${Name}/:${IdName}`,\n                  WithParams<\n                    Omit<I, never> & {\n                      bodySchema: C['update'] extends CrudUpdateCfg\n                        ? C['update']['bodySchema']\n                        : never;\n                      outputSchema: C['update'] extends CrudUpdateCfg\n                        ? C['update']['outputSchema'] extends ZodTypeAny\n                          ? C['update']['outputSchema']\n                          : C['itemOutputSchema']\n                        : never;\n                      description?: string;\n                    },\n                    ReturnType<typeof mergeSchemas<PS, IdParamZ>>\n                  >\n                >,\n              ]\n            : []\n          : []),\n\n        // DELETE /collection/:id\n        ...(Flag<\n          C['enable'] extends CrudEnable ? C['enable']['remove'] : undefined,\n          true\n        > extends true\n          ? [\n              Leaf<\n                'delete',\n                `${Base}/${Name}/:${IdName}`,\n                WithParams<\n                  Omit<I, never> & {\n                    outputSchema: C['remove'] extends CrudRemoveCfg\n                      ? C['remove']['outputSchema'] extends ZodTypeAny\n                        ? C['remove']['outputSchema']\n                        : z.ZodObject<{ ok: z.ZodLiteral<true> }>\n                      : z.ZodObject<{ ok: z.ZodLiteral<true> }>;\n                    description?: string;\n                  },\n                  ReturnType<typeof mergeSchemas<PS, IdParamZ>>\n                >\n              >,\n            ]\n          : []),\n      ]\n    : never\n  : never;\n\n/** Merge generated leaves + extras into the branch accumulator. */\ntype CrudResultAcc<\n  Base extends string,\n  Acc extends readonly AnyLeaf[],\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n  Name extends string,\n  C extends CrudCfg<Name>,\n  Extras extends readonly AnyLeaf[],\n> = [...Acc, ...CrudLeavesTuple<Base, I, PS, Name, C>, ...Extras];\n\n// -----------------------------------------------------------------------------\n// Module augmentation: add the typed `.crud(...)` to Branch<...>\n// -----------------------------------------------------------------------------\n\ndeclare module './../core/routesV3.builder' {\n  interface Branch<\n    Base extends string,\n    Acc extends readonly AnyLeaf[],\n    I extends NodeCfg,\n    PS extends ZodTypeAny | undefined,\n  > {\n    /**\n     * Generate opinionated CRUD endpoints for a collection at `/.../<name>`\n     * with an item at `/.../<name>/:<name>Id`.\n     *\n     * Creates (subject to `enable` + presence of create/update bodies):\n     * - GET    /<name>                (feed list)\n     * - POST   /<name>                (create)\n     * - GET    /<name>/:<name>Id      (read item)\n     * - PATCH  /<name>/:<name>Id      (update item)\n     * - DELETE /<name>/:<name>Id      (remove item)\n     *\n     * The `extras` callback receives live builders at both collection and item\n     * levels so you can add custom subroutes; their leaves are included in the\n     * returned Branch type.\n     */\n    crud<\n      Name extends string,\n      C extends CrudCfg<Name>,\n      Extras extends readonly AnyLeaf[] = readonly [],\n    >(\n      name: Name,\n      cfg: C,\n      extras?: (ctx: {\n        /** Builder at `/.../<name>` (collection scope). */\n        collection: _Branch<`${Base}/${Name}`, readonly [], I, PS>;\n        /** Builder at `/.../<name>/:<name>Id` (item scope). */\n        item: _Branch<\n          `${Base}/${Name}/:${`${Name}Id`}`,\n          readonly [],\n          I,\n          ReturnType<typeof mergeSchemas<PS, ParamSchema<`${Name}Id`, C['paramSchema']>>>\n        >;\n      }) => Extras,\n    ): _Branch<Base, CrudResultAcc<Base, Acc, I, PS, Name, C, Extras>, I, PS>;\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Runtime: install .crud on any Branch via decorator\n// -----------------------------------------------------------------------------\n\n/**\n * Decorate a Branch instance so `.crud(...)` is available at runtime.\n * Tip: wrap the root: `withCrud(resource('/v1'))`.\n * @param branch Branch returned by `resource(...)`.\n * @returns Same branch with `.crud(...)` installed.\n */\nexport function withCrud<\n  Base extends string,\n  Acc extends readonly AnyLeaf[],\n  I extends NodeCfg,\n  PS extends ZodTypeAny | undefined,\n>(branch: _Branch<Base, Acc, I, PS>): _Branch<Base, Acc, I, PS> {\n  const b = branch as any;\n  if (typeof b.crud === 'function') return branch;\n\n  b.crud = function <\n    Name extends string,\n    C extends CrudCfg<Name>,\n    Extras extends readonly AnyLeaf[] = readonly [],\n  >(this: any, name: Name, cfg: C, extras?: (ctx: { collection: any; item: any }) => Extras) {\n    // Build inside a sub-branch at `/.../<name>` and harvest its leaves.\n    return this.sub(name, (collection: any) => {\n      const idKey = `${name}Id`;\n\n      // Accept a value schema (preferred); but if a z.object({[name]Id: ...}) is provided, use it.\n      const s = cfg.paramSchema;\n      const isObj =\n        s &&\n        typeof (s as any)._def === 'object' &&\n        (s as any)._def.typeName === 'ZodObject' &&\n        typeof (s as any).shape === 'function';\n\n      const paramObj =\n        isObj && (s as any).shape()[idKey]\n          ? (s as ZodTypeAny)\n          : z.object({ [idKey]: s } as Record<string, ZodTypeAny>);\n\n      const itemOut = cfg.itemOutputSchema;\n      const listOut =\n        cfg.list?.outputSchema ??\n        z.object({\n          items: z.array(itemOut),\n          nextCursor: z.string().optional(),\n        });\n\n      const want = {\n        list: cfg.enable?.list !== false,\n        create: cfg.enable?.create !== false && !!cfg.create?.bodySchema,\n        read: cfg.enable?.read !== false,\n        update: cfg.enable?.update !== false && !!cfg.update?.bodySchema,\n        remove: cfg.enable?.remove !== false,\n      } as const;\n\n      // Collection routes\n      if (want.list) {\n        const c = cfg.list?.authenticated ? collection.with({ authenticated: true }) : collection;\n        c.get({\n          feed: true,\n          querySchema: cfg.list?.querySchema ?? CrudDefaultPagination,\n          outputSchema: listOut,\n          description: cfg.list?.description ?? 'List',\n        });\n      }\n\n      if (want.create) {\n        const c = cfg.create?.authenticated ? collection.with({ authenticated: true }) : collection;\n        c.post({\n          bodySchema: cfg.create!.bodySchema,\n          outputSchema: cfg.create?.outputSchema ?? itemOut,\n          description: cfg.create?.description ?? 'Create',\n        });\n      }\n\n      // Item routes via :<name>Id\n      collection.routeParameter(idKey as any, paramObj as any, (item: any) => {\n        if (want.read) {\n          const i = cfg.read?.authenticated ? item.with({ authenticated: true }) : item;\n          i.get({\n            outputSchema: cfg.read?.outputSchema ?? itemOut,\n            description: cfg.read?.description ?? 'Read',\n          });\n        }\n        if (want.update) {\n          const i = cfg.update?.authenticated ? item.with({ authenticated: true }) : item;\n          i.patch({\n            bodySchema: cfg.update!.bodySchema,\n            outputSchema: cfg.update?.outputSchema ?? itemOut,\n            description: cfg.update?.description ?? 'Update',\n          });\n        }\n        if (want.remove) {\n          const i = cfg.remove?.authenticated ? item.with({ authenticated: true }) : item;\n          i.delete({\n            outputSchema: cfg.remove?.outputSchema ?? z.object({ ok: z.literal(true) }),\n            description: cfg.remove?.description ?? 'Delete',\n          });\n        }\n\n        // Give extras fully-capable builders (decorate so extras can call .crud again)\n        if (extras) extras({ collection: withCrud(collection), item: withCrud(item) });\n\n        return item.done();\n      });\n\n      return collection.done();\n    });\n  };\n\n  return branch;\n}\n\n// -----------------------------------------------------------------------------\n// Optional convenience: re-export a resource() that already has .crud installed\n// -----------------------------------------------------------------------------\n\n/**\n * Drop-in replacement for `resource(...)` that returns a Branch with `.crud()` installed.\n * You can either use this or call `withCrud(resource(...))`.\n * @param base Root path for the resource (e.g. `/v1`).\n * @param inherited Node configuration merged into every leaf.\n * @returns Branch builder that already includes the CRUD helper.\n */\nexport function resourceWithCrud<Base extends string, I extends NodeCfg = {}>(\n  base: Base,\n  inherited: I,\n) {\n  return withCrud(baseResource(base, inherited));\n}\n\n// Re-export the original in case you want both styles from this module\nexport { baseResource as resource };\n"],"mappings":"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","names":["z","z","mergeSchemas"]}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@emeryld/rrroutes-contract",
+  "version": "1.1.0",
+  "private": false,
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^4.1.8"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.2.0"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "pnpm run clean && pnpm run build:js && pnpm run build:types",
+    "build:js": "tsup src/index.ts --sourcemap --format esm,cjs --out-dir dist",
+    "build:types": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}