@c9up/ream 0.1.25 → 0.1.27

package/src/testing/TestClient.ts

@@ -23,46 +23,39 @@ import {
   type HttpMethod,
   type HttpSender,
   RequestBuilder,
+  type TestResponse,
 } from './RequestBuilder.js'
 
-export interface TestResponse {
-  status: number
-  headers: Dict
-  body: string
-  json<T = unknown>(): T
-}
+// The raw response shape + the rich response live in ApiResponse.ts and are
+// re-exported here so `@c9up/ream/testing` consumers keep their import path.
+export { ApiResponse, type TestResponse } from './RequestBuilder.js'
 
 /**
- * Fluent request builder. Thenable like AdonisJS/japa's api-client: `await
- * client.get('/x')` sends the request, and chaining works on every verb —
- * `await client.get('/x').header('authorization', token)`. The explicit
- * `.send()` is kept for callers that prefer it.
+ * Named-route manifest — `name → path pattern`, e.g. `{ 'users.show':
+ * '/users/:id' }`. Feed `router.namedManifest()` here so `visit()` can resolve
+ * named routes without the full Router.
+ *
+ * A value may be a bare path string OR `{ path, method }` — when the method is
+ * present, `visit(name)` uses it (Japa route-registry parity, e.g.
+ * `visit('users.store').json(...).assertCreated()` issues a POST).
  */
-export interface TestRequestBuilder extends PromiseLike<TestResponse> {
-  /** Set a request header. */
-  header(name: string, value: string): TestRequestBuilder
-  /** Set the request body as JSON. */
-  json(data: unknown): TestRequestBuilder
-  /** Set a raw string body with optional content type. */
-  body(content: string, contentType?: string): TestRequestBuilder
-  /** Set a cookie. */
-  cookie(name: string, value: string): TestRequestBuilder
-  /** Send the request and return the response. */
-  send(): Promise<TestResponse>
-}
+export type RouteEntry = string | { path: string; method?: HttpMethod }
+export type RouteManifest = Record<string, RouteEntry>
 
 export class TestClient {
   #port = 0
   #headers: Dict = {}
   #bootFn: (port: number) => Promise<{ port: number; close: () => Promise<void> | void }>
   #auth: AuthStrategy | null
+  #routes: RouteManifest | null
 
   constructor(
     bootFn: (port: number) => Promise<{ port: number; close: () => Promise<void> | void }>,
-    options: { auth?: AuthStrategy } = {},
+    options: { auth?: AuthStrategy; routes?: RouteManifest } = {},
   ) {
     this.#bootFn = bootFn
     this.#auth = options.auth ?? null
+    this.#routes = options.routes ?? null
   }
 
   #server: { port: number; close: () => Promise<void> | void } | null = null
@@ -97,29 +90,47 @@ export class TestClient {
     return this
   }
 
-  /** GET request. Returns a chainable, awaitable builder (await sends it). */
-  get(path: string): TestRequestBuilder {
-    return this.request('GET', path)
+  // Verb shortcuts return the RICH builder — the full japa/api-client surface
+  // (assertOk/assertStatus/assertBody/… + auth/csrf) AND awaitable (`await
+  // client.get('/x')` sends and resolves to the response). One unified builder,
+  // no split between `get()` and `fluent()`.
+
+  /** GET request — rich, awaitable builder. */
+  get(path: string): RequestBuilder {
+    return this.fluent('GET', path)
+  }
+
+  /** POST request — rich, awaitable builder. */
+  post(path: string): RequestBuilder {
+    return this.fluent('POST', path)
   }
 
-  /** POST request. */
-  post(path: string): TestRequestBuilder {
-    return this.request('POST', path)
+  /** PUT request — rich, awaitable builder. */
+  put(path: string): RequestBuilder {
+    return this.fluent('PUT', path)
   }
 
-  /** PUT request. */
-  put(path: string): TestRequestBuilder {
-    return this.request('PUT', path)
+  /** PATCH request — rich, awaitable builder. */
+  patch(path: string): RequestBuilder {
+    return this.fluent('PATCH', path)
   }
 
-  /** PATCH request. */
-  patch(path: string): TestRequestBuilder {
-    return this.request('PATCH', path)
+  /** DELETE request — rich, awaitable builder. */
+  delete(path: string): RequestBuilder {
+    return this.fluent('DELETE', path)
   }
 
-  /** DELETE request. Returns a chainable, awaitable builder (await sends it). */
-  delete(path: string): TestRequestBuilder {
-    return this.request('DELETE', path)
+  /**
+   * HEAD request — japa/api-client's `.head()`. Returns the rich builder so you
+   * can assert status/headers (a HEAD response carries headers, no body).
+   */
+  head(path: string): RequestBuilder {
+    return this.fluent('HEAD', path)
+  }
+
+  /** OPTIONS request — japa/api-client's `.options()`. */
+  options(path: string): RequestBuilder {
+    return this.fluent('OPTIONS', path)
   }
 
   /**
@@ -136,49 +147,37 @@ export class TestClient {
         p,
         { ...this.#headers, ...init.headers },
         init.body.toString('utf8'),
+        init.timeoutMs,
       )
     return new RequestBuilder(sender, method, path, this.#auth)
   }
 
-  /** Build a request with the low-level fluent API. */
-  request(method: string, path: string): TestRequestBuilder {
-    const headers: Dict = { ...this.#headers }
-    let bodyContent = ''
-    const cookies: string[] = []
-
-    const builder: TestRequestBuilder = {
-      header(name: string, value: string) {
-        headers[name.toLowerCase()] = value
-        return builder
-      },
-      json(data: unknown) {
-        bodyContent = JSON.stringify(data)
-        headers['content-type'] = 'application/json'
-        return builder
-      },
-      body(content: string, contentType?: string) {
-        bodyContent = content
-        if (contentType) headers['content-type'] = contentType
-        return builder
-      },
-      cookie(name: string, value: string) {
-        cookies.push(`${name}=${value}`)
-        return builder
-      },
-      send: async () => {
-        if (cookies.length > 0) {
-          headers.cookie = cookies.join('; ')
-        }
-        return sendRequest(this.#port, method, path, headers, bodyContent)
-      },
-      // Thenable: `await client.get('/x')` (or any builder) sends the request,
-      // matching AdonisJS/japa's api-client ergonomics. The `then` IS the public
-      // contract here — awaiting the builder is the documented way to send.
-      // biome-ignore lint/suspicious/noThenProperty: thenable request builder is the intended API (AdonisJS/japa parity) — `await client.get(path)` sends
-      then: (onfulfilled, onrejected) => builder.send().then(onfulfilled, onrejected),
+  /**
+   * GET a named route — japa/api-client's `.visit()`. Resolves `name` against
+   * the `routes` manifest (`router.namedManifest()`), fills `:param`
+   * placeholders, and returns the rich chainable builder. Throws a clear error
+   * when no manifest was configured or the name is unknown.
+   */
+  visit(name: string, params?: Record<string, string>): RequestBuilder {
+    if (!this.#routes) {
+      throw new Error(
+        'TestClient: visit() needs a named-route manifest. Pass `routes: router.namedManifest()` in the client options.',
+      )
     }
+    const entry = this.#routes[name]
+    // Method comes from the registry when the entry carries one (Japa parity),
+    // otherwise GET.
+    const method: HttpMethod = typeof entry === 'object' && entry.method ? entry.method : 'GET'
+    return this.fluent(method, resolveNamedRoute(this.#routes, name, params))
+  }
 
-    return builder
+  /**
+   * Generic request — japa/api-client's `client.request(url, method)` (note the
+   * arg order: URL first, method second, defaulting to GET). Returns the same
+   * rich, awaitable builder as the verb shortcuts.
+   */
+  request(path: string, method: HttpMethod = 'GET'): RequestBuilder {
+    return this.fluent(method, path)
   }
 }
 
@@ -198,9 +197,41 @@ export {
   type HttpMethod,
   type HttpSender,
   partialMatch,
+  type QueryParams,
   RequestBuilder,
 } from './RequestBuilder.js'
 
+/**
+ * Resolve a named route against a manifest — the client-side twin of
+ * `Router.urlFor`. Fills `:param` placeholders (word-boundary safe), strips
+ * unprovided `:optional?` segments, and throws on an unknown name or a missing
+ * required param.
+ */
+export function resolveNamedRoute(
+  manifest: RouteManifest,
+  name: string,
+  params?: Record<string, string>,
+): string {
+  const entry = manifest[name]
+  if (entry === undefined) {
+    const available = Object.keys(manifest).join(', ') || '(none)'
+    throw new Error(`Route '${name}' not found. Available: ${available}`)
+  }
+  let url = typeof entry === 'string' ? entry : entry.path
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      url = url.replace(new RegExp(`:${escaped}\\??(?![\\w])`, 'g'), encodeURIComponent(value))
+    }
+  }
+  url = url.replace(/\/:[A-Za-z_][\w]*\?/g, '')
+  const missing = url.match(/:[A-Za-z_][\w]*/g)
+  if (missing && missing.length > 0) {
+    throw new Error(`Cannot generate URL for route '${name}': missing params ${missing.join(', ')}`)
+  }
+  return url
+}
+
 /** Send an HTTP request using raw TCP (no external dependencies). */
 async function sendRequest(
   port: number,
@@ -208,6 +239,7 @@ async function sendRequest(
   path: string,
   headers: Dict,
   body: string,
+  timeoutMs?: number,
 ): Promise<TestResponse> {
   const { connect } = await import('node:net')
 
@@ -253,8 +285,9 @@ async function sendRequest(
     // tokio runtimes) the cumulative latency exceeded 5s ~30% of runs
     // and surfaced as flaky `bob accepts` / `non-member 403` failures
     // in kitchen-sink's workspace.test.ts. 30s matches the helix
-    // `--timeout=60000` per-test budget without masking real hangs.
-    socket.setTimeout(30_000, () => {
+    // `--timeout=60000` per-test budget without masking real hangs. A
+    // per-request `.timeout(ms)` (Japa) overrides the default.
+    socket.setTimeout(timeoutMs && timeoutMs > 0 ? timeoutMs : 30_000, () => {
       socket.destroy()
       reject(new Error('TestClient request timed out'))
     })

package/src/utils/Macroable.ts

@@ -0,0 +1,54 @@
+/**
+ * Macroable — lets a package extend a class at runtime with extra methods
+ * (`macro`) and computed properties (`getter`), AdonisJS-style. A framework
+ * class (Request, Response, HttpContext, Router, …) extends this so an add-on
+ * can attach behaviour without a subclass:
+ *
+ *   Request.macro('wantsJson', function () { return this.accepts(['json']) === 'json' })
+ *   HttpContext.getter('tenant', function () { return resolveTenant(this) })
+ *
+ * TypeScript sees only the base class; consumers type their macros with
+ * declaration merging (`declare module`) exactly as in AdonisJS.
+ */
+
+/**
+ * A macro method. When invoked, `this` is the instance it's attached to —
+ * declare it explicitly in your callback (`function (this: Request) { … }`) to
+ * type the receiver; the alias itself leaves `this` open so any class fits.
+ */
+export type MacroFn = (...args: unknown[]) => unknown
+
+/** A getter implementation — declare `this` in your callback to type the receiver. */
+export type GetterFn = () => unknown
+
+export class Macroable {
+  /** Attach a method to every instance of this class (AdonisJS `macro`). */
+  static macro(name: string, fn: MacroFn): void {
+    Object.defineProperty(Macroable.prototype, name, {
+      value: fn,
+      writable: true,
+      configurable: true,
+    })
+  }
+
+  /**
+   * Attach a computed property to every instance (AdonisJS `getter`). With
+   * `singleton`, the value is computed once per instance and cached.
+   */
+  static getter(name: string, fn: GetterFn, singleton = false): void {
+    if (!singleton) {
+      Object.defineProperty(Macroable.prototype, name, { get: fn, configurable: true })
+      return
+    }
+    const cacheKey = Symbol(name)
+    Object.defineProperty(Macroable.prototype, name, {
+      configurable: true,
+      get(this: Record<symbol, unknown>) {
+        if (!(cacheKey in this)) {
+          Object.defineProperty(this, cacheKey, { value: fn.call(this), configurable: true })
+        }
+        return this[cacheKey]
+      },
+    })
+  }
+}

package/src/utils/inflect.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal zero-dependency string inflection — the two operations resourceful
+ * routing needs from AdonisJS's `@poppinss/utils/string`: `snakeCase` (route
+ * name normalisation) and `singular` (nested-resource param naming, `photos`
+ * → `photo_id`).
+ *
+ * Deviation from AdonisJS (named): `singular` covers regular English plurals
+ * only (`-ies→-y`, `-(s|x|z|ch|sh)es→drop es`, trailing `-s→drop`). Irregular
+ * plurals (`people→person`, `geese→goose`) are NOT handled — resource names in
+ * REST APIs are overwhelmingly regular, and a full inflector (irregular tables,
+ * uncountables) would be a dependency-sized rabbit hole for a niche case.
+ */
+
+/** Convert `camelCase`/`PascalCase`/`kebab-case`/spaced text to `snake_case`. */
+export function snakeCase(value: string): string {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[-\s]+/g, '_')
+    .toLowerCase()
+}
+
+/** Singularize a regular English plural (see module deviation note). */
+export function singular(word: string): string {
+  if (word.length > 3 && /ies$/i.test(word)) return word.replace(/ies$/i, 'y')
+  if (/(?:s|x|z|ch|sh)es$/i.test(word)) return word.replace(/es$/i, '')
+  if (/ss$/i.test(word)) return word
+  if (/s$/i.test(word)) return word.replace(/s$/i, '')
+  return word
+}

package/src/utils/objectPath.ts

@@ -0,0 +1,142 @@
+/**
+ * Zero-dependency dot-path object access — the small subset of `lodash`
+ * (`get`/`set`/`has`/`pick`/`omit`/`merge`) that Config and Request need for
+ * AdonisJS-parity nested access (`config.get('database.mysql.host')`,
+ * `request.input('user.address.city')`).
+ *
+ * AdonisJS uses `@poppinss/utils/lodash` for this. Ream stays lean and
+ * dependency-free (same stance as aurora's hand-written `cn`/`clsx`), so we
+ * reimplement exactly the four semantics we rely on — no more.
+ *
+ * Path syntax: `a.b.c` and `a[0].c` / `a.0.c` (bracket + dotted indices) are
+ * both accepted, matching lodash's tokenizer for the shapes config/request
+ * data actually take (plain JSON objects and arrays).
+ */
+
+/** A JSON-ish record we can index by string key. */
+type UnknownRecord = Record<string, unknown>
+
+/** True for plain objects and arrays (anything indexable by a path segment). */
+function isIndexable(value: unknown): value is UnknownRecord {
+  return typeof value === 'object' && value !== null
+}
+
+/**
+ * Split a dot/bracket path into segments: `a.b[0].c` → `['a','b','0','c']`.
+ * A single already-simple key (no `.`/`[`) is returned as-is, so keys that
+ * happen to contain neither delimiter cost nothing.
+ */
+function toSegments(path: string): string[] {
+  if (path.indexOf('.') === -1 && path.indexOf('[') === -1) return [path]
+  const segments: string[] = []
+  const matcher = /[^.[\]]+/g
+  let match: RegExpExecArray | null = matcher.exec(path)
+  while (match !== null) {
+    segments.push(match[0])
+    match = matcher.exec(path)
+  }
+  return segments
+}
+
+/**
+ * Read a nested value by dot-path. Returns `defaultValue` when any segment is
+ * missing or the resolved value is `undefined` (lodash.get semantics).
+ */
+export function getPath(source: unknown, path: string, defaultValue?: unknown): unknown {
+  const segments = toSegments(path)
+  let current: unknown = source
+  for (const segment of segments) {
+    if (!isIndexable(current)) return defaultValue
+    current = current[segment]
+  }
+  return current === undefined ? defaultValue : current
+}
+
+/**
+ * True when the full dot-path exists on `source` (each segment is an own key),
+ * even if the leaf value is `undefined` (lodash.has semantics).
+ */
+export function hasPath(source: unknown, path: string): boolean {
+  const segments = toSegments(path)
+  let current: unknown = source
+  for (const segment of segments) {
+    if (!isIndexable(current) || !Object.hasOwn(current, segment)) return false
+    current = current[segment]
+  }
+  return true
+}
+
+/**
+ * Set a nested value by dot-path, creating intermediate plain objects as
+ * needed, and return the (mutated) root.
+ *
+ * Deviation from lodash.set (named): integer segments create plain objects,
+ * NOT arrays. Config trees and request-data picks are keyed objects; ream
+ * never sets array indices through a path, so array auto-vivification would be
+ * dead behaviour.
+ */
+export function setPath(target: UnknownRecord, path: string, value: unknown): UnknownRecord {
+  const segments = toSegments(path)
+  let current: UnknownRecord = target
+  for (let i = 0; i < segments.length - 1; i += 1) {
+    const key = segments[i]
+    const next = current[key]
+    if (!isIndexable(next)) {
+      const created: UnknownRecord = {}
+      current[key] = created
+      current = created
+    } else {
+      current = next
+    }
+  }
+  current[segments[segments.length - 1]] = value
+  return target
+}
+
+/**
+ * Return a new object containing only the given dot-paths (lodash.pick).
+ * Missing paths are skipped; nested paths reconstruct their branch, so
+ * `pickPaths({a:{b:1,c:2}}, ['a.b'])` yields `{a:{b:1}}`.
+ */
+export function pickPaths(source: unknown, paths: string[]): UnknownRecord {
+  const result: UnknownRecord = {}
+  for (const path of paths) {
+    if (hasPath(source, path)) setPath(result, path, getPath(source, path))
+  }
+  return result
+}
+
+/**
+ * Return a deep clone of `source` with the given dot-paths removed
+ * (lodash.omit). Operates on JSON-ish data (body + query), so `structuredClone`
+ * is a safe deep copy that never mutates the caller's input.
+ */
+export function omitPaths(source: UnknownRecord, paths: string[]): UnknownRecord {
+  const result = structuredClone(source)
+  for (const path of paths) {
+    const segments = toSegments(path)
+    let current: unknown = result
+    for (let i = 0; i < segments.length - 1; i += 1) {
+      if (!isIndexable(current)) break
+      current = current[segments[i]]
+    }
+    if (isIndexable(current)) delete current[segments[segments.length - 1]]
+  }
+  return result
+}
+
+/**
+ * Deep-merge `source` over `target` (recursively for nested plain objects;
+ * scalars and arrays from `source` replace `target`). Returns a new object;
+ * neither input is mutated. Backs `Config.defaults` — the AdonisJS semantics
+ * where existing config wins over provided defaults.
+ */
+export function mergeDeep(target: unknown, source: unknown): unknown {
+  if (!isIndexable(target) || Array.isArray(target)) return source === undefined ? target : source
+  if (!isIndexable(source) || Array.isArray(source)) return source === undefined ? target : source
+  const out: UnknownRecord = { ...target }
+  for (const key of Object.keys(source)) {
+    out[key] = mergeDeep(out[key], source[key])
+  }
+  return out
+}

package/dist/console/CommandRunner.d.ts

@@ -1,18 +0,0 @@
-/**
- * CommandRunner — minimal CLI command framework.
- *
- * Registers commands and dispatches based on argv.
- * Like AdonisJS Ace but lightweight.
- */
-export interface Command {
-    name: string;
-    description: string;
-    run(args: string[], flags: Record<string, string | boolean>): Promise<void>;
-}
-export declare class CommandRunner {
-    #private;
-    register(command: Command): this;
-    handle(argv: string[]): Promise<void>;
-    getCommands(): Map<string, Command>;
-}
-//# sourceMappingURL=CommandRunner.d.ts.map

package/dist/console/CommandRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CommandRunner.d.ts","sourceRoot":"","sources":["../../src/console/CommandRunner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5E;AAED,qBAAa,aAAa;;IAGxB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAK1B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA2B3C,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;CAGpC"}

package/dist/console/CommandRunner.js

@@ -1,65 +0,0 @@
-/**
- * CommandRunner — minimal CLI command framework.
- *
- * Registers commands and dispatches based on argv.
- * Like AdonisJS Ace but lightweight.
- */
-export class CommandRunner {
-    #commands = new Map();
-    register(command) {
-        this.#commands.set(command.name, command);
-        return this;
-    }
-    async handle(argv) {
-        const { commandName, args, flags } = parseArgv(argv);
-        if (!commandName || commandName === 'help') {
-            this.#printHelp();
-            return;
-        }
-        const command = this.#commands.get(commandName);
-        if (!command) {
-            console.error(`Unknown command: ${commandName}`);
-            console.error(`Run without arguments to see available commands.`);
-            process.exitCode = 1;
-            return;
-        }
-        await command.run(args, flags);
-    }
-    #printHelp() {
-        console.log('\nAvailable commands:\n');
-        for (const [name, cmd] of this.#commands) {
-            console.log(`  ${name.padEnd(25)} ${cmd.description}`);
-        }
-        console.log('');
-    }
-    getCommands() {
-        return new Map(this.#commands);
-    }
-}
-function parseArgv(argv) {
-    const flags = {};
-    const positional = [];
-    for (const arg of argv) {
-        if (arg.startsWith('--')) {
-            const eqIdx = arg.indexOf('=');
-            if (eqIdx !== -1) {
-                flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
-            }
-            else {
-                flags[arg.slice(2)] = true;
-            }
-        }
-        else if (arg.startsWith('-') && arg.length === 2) {
-            flags[arg.slice(1)] = true;
-        }
-        else {
-            positional.push(arg);
-        }
-    }
-    return {
-        commandName: positional[0],
-        args: positional.slice(1),
-        flags,
-    };
-}
-//# sourceMappingURL=CommandRunner.js.map

package/dist/console/CommandRunner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CommandRunner.js","sourceRoot":"","sources":["../../src/console/CommandRunner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,OAAO,aAAa;IACxB,SAAS,GAAyB,IAAI,GAAG,EAAE,CAAA;IAE3C,QAAQ,CAAC,OAAgB;QACvB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QACzC,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,IAAc;QACzB,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;QAEpD,IAAI,CAAC,WAAW,IAAI,WAAW,KAAK,MAAM,EAAE,CAAC;YAC3C,IAAI,CAAC,UAAU,EAAE,CAAA;YACjB,OAAM;QACR,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;QAC/C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,oBAAoB,WAAW,EAAE,CAAC,CAAA;YAChD,OAAO,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAA;YACjE,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAA;YACpB,OAAM;QACR,CAAC;QAED,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAChC,CAAC;IAED,UAAU;QACR,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAA;QACtC,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACzC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,WAAW,EAAE,CAAC,CAAA;QACxD,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACjB,CAAC;IAED,WAAW;QACT,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IAChC,CAAC;CACF;AAED,SAAS,SAAS,CAAC,IAAc;IAK/B,MAAM,KAAK,GAAqC,EAAE,CAAA;IAClD,MAAM,UAAU,GAAa,EAAE,CAAA;IAE/B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YAC9B,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;YACnD,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;YAC5B,CAAC;QACH,CAAC;aAAM,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnD,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;QAC5B,CAAC;aAAM,CAAC;YACN,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QACtB,CAAC;IACH,CAAC;IAED,OAAO;QACL,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;QAC1B,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;QACzB,KAAK;KACN,CAAA;AACH,CAAC"}

package/dist/decorators/Lazy.d.ts

@@ -1,19 +0,0 @@
-/**
- * @Lazy() decorator — deferred injection to break circular dependencies.
- *
- * @implements FR15
- */
-import 'reflect-metadata';
-/**
- * @Lazy() — marks a constructor parameter for deferred resolution.
- * The dependency is resolved on first property access, not at construction.
- */
-export declare function Lazy(): ParameterDecorator;
-/** Get lazy parameter indices for a constructor. */
-export declare function getLazyParams(target: object): number[];
-/**
- * Create a lazy proxy that defers resolution until first access.
- * Traps get, set, has, ownKeys, getOwnPropertyDescriptor for full compatibility.
- */
-export declare function createLazyProxy<T extends object>(resolver: () => T): T;
-//# sourceMappingURL=Lazy.d.ts.map

package/dist/decorators/Lazy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Lazy.d.ts","sourceRoot":"","sources":["../../src/decorators/Lazy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,kBAAkB,CAAA;AAIzB;;;GAGG;AACH,wBAAgB,IAAI,IAAI,kBAAkB,CAMzC;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEtD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAyBtE"}

package/dist/decorators/Lazy.js

@@ -1,53 +0,0 @@
-/**
- * @Lazy() decorator — deferred injection to break circular dependencies.
- *
- * @implements FR15
- */
-import 'reflect-metadata';
-const LAZY_KEY = Symbol.for('ream:lazy');
-/**
- * @Lazy() — marks a constructor parameter for deferred resolution.
- * The dependency is resolved on first property access, not at construction.
- */
-export function Lazy() {
-    return (target, propertyKey, parameterIndex) => {
-        const existing = Reflect.getOwnMetadata(LAZY_KEY, target, propertyKey ?? '') ?? [];
-        existing.push(parameterIndex);
-        Reflect.defineMetadata(LAZY_KEY, existing, target, propertyKey ?? '');
-    };
-}
-/** Get lazy parameter indices for a constructor. */
-export function getLazyParams(target) {
-    return Reflect.getOwnMetadata(LAZY_KEY, target, '') ?? [];
-}
-/**
- * Create a lazy proxy that defers resolution until first access.
- * Traps get, set, has, ownKeys, getOwnPropertyDescriptor for full compatibility.
- */
-export function createLazyProxy(resolver) {
-    let instance;
-    const ensure = () => {
-        if (!instance)
-            instance = resolver();
-        return instance;
-    };
-    // biome-ignore lint/suspicious/noExplicitAny: Proxy target must be an object literal; T is branded at call site
-    return new Proxy({}, {
-        get(_target, prop, receiver) {
-            return Reflect.get(ensure(), prop, receiver);
-        },
-        set(_target, prop, value, receiver) {
-            return Reflect.set(ensure(), prop, value, receiver);
-        },
-        has(_target, prop) {
-            return Reflect.has(ensure(), prop);
-        },
-        ownKeys() {
-            return Reflect.ownKeys(ensure());
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            return Object.getOwnPropertyDescriptor(ensure(), prop);
-        },
-    });
-}
-//# sourceMappingURL=Lazy.js.map

package/dist/decorators/Lazy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Lazy.js","sourceRoot":"","sources":["../../src/decorators/Lazy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,kBAAkB,CAAA;AAEzB,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AAExC;;;GAGG;AACH,MAAM,UAAU,IAAI;IAClB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,EAAE;QAC7C,MAAM,QAAQ,GAAa,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,IAAI,EAAE,CAAC,IAAI,EAAE,CAAA;QAC5F,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAC7B,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,IAAI,EAAE,CAAC,CAAA;IACvE,CAAC,CAAA;AACH,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,aAAa,CAAC,MAAc;IAC1C,OAAO,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,EAAE,CAAA;AAC3D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAmB,QAAiB;IACjE,IAAI,QAAuB,CAAA;IAC3B,MAAM,MAAM,GAAG,GAAM,EAAE;QACrB,IAAI,CAAC,QAAQ;YAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;QACpC,OAAO,QAAQ,CAAA;IACjB,CAAC,CAAA;IAED,gHAAgH;IAChH,OAAO,IAAI,KAAK,CAAC,EAAc,EAAE;QAC/B,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ;YACzB,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAA;QAC9C,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ;YAChC,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAA;QACrD,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,IAAI;YACf,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,CAAA;QACpC,CAAC;QACD,OAAO;YACL,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;QAClC,CAAC;QACD,wBAAwB,CAAC,OAAO,EAAE,IAAI;YACpC,OAAO,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,CAAA;QACxD,CAAC;KACF,CAAC,CAAA;AACJ,CAAC"}