@setu-ts/kernel 0.0.0-stage → 0.10.0

package/dist/router/router.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Router — programmatic route registration with method-based matching,
+ * parameter extraction, group facades, and static-over-param preference.
+ *
+ * Route matching is delegated to Hono as of Milestone 22; the kernel
+ * maintains a `RouteEntry` map so it can return `{ definition, params }`
+ * in the same shape the pipeline terminal expects, and apply its own
+ * deterministic tie-break (§3.6) when Hono returns multiple candidates.
+ *
+ * @module
+ */
+import type { HttpMethod, IRouterApi, RouteDefinition, RouteHandler, RouteInfo } from '@setu-ts/common';
+export interface RouteEntry {
+    pattern: string;
+    method: HttpMethod;
+    definition: RouteDefinition;
+    index: number;
+    /**
+     * Static-segment count — hoisted to registration time (AI_GUIDELINES §14) and
+     * read by the tie-break in {@linkcode Router.match}.
+     *
+     * The parsed `Segment[]` it is derived from is deliberately NOT retained: it
+     * was stored on every entry and read by nothing once Hono took over matching
+     * in M22.
+     */
+    statics: number;
+    /**
+     * Wildcard-segment count — hoisted at registration beside {@linkcode
+     * RouteEntry.statics} and read ASCENDING by the tie-break in {@linkcode
+     * Router.match}.
+     *
+     * Before M70g a `*` was counted as a static segment, so `/*` tied with
+     * `/openapi.json` and outranked `/a/:id`. Counting it separately is what makes
+     * an application catch-all sort last instead of eating every single-segment
+     * route registered after it.
+     */
+    wildcards: number;
+    /** Plugin that registered this route, if it was registered by a plugin. */
+    owner?: string;
+}
+/**
+ * A route registration reported to the diagnostics collector at its owning
+ * mutation boundary, carrying only bounded registration primitives.
+ *
+ * @since 0.8.0
+ */
+export interface RouteRegistrationEvent {
+    readonly kind: 'register';
+    /** The entry's insertion index — the identity dispatch uses to name the route. */
+    readonly entryIndex: number;
+    /**
+     * The method as registered — typed as the raw string deliberately, because
+     * projecting onto the supported verb vocabulary is the COLLECTOR's decision
+     * (unsupported input is omitted there, never widened).
+     */
+    readonly method: string;
+    /** The COMPLETE registered pattern, including any group prefix. */
+    readonly pattern: string;
+    /** The plugin that registered the route, when one was registering. */
+    readonly owner: string | undefined;
+    /** How many middleware stages the route's definition declares. */
+    readonly middlewareCount: number;
+}
+export declare class Router implements IRouterApi {
+    #private;
+    constructor(owner?: () => string | undefined);
+    /**
+     * Installs the diagnostics sink that receives route registration events at
+     * the owning mutation boundary. Pass `undefined` to detach (teardown).
+     *
+     * @param sink - The collector-facing sink, or `undefined`
+     * @since 0.8.0
+     */
+    setDiagnosticsSink(sink: ((event: RouteRegistrationEvent) => void) | undefined): void;
+    get(path: string, route: RouteHandler | RouteDefinition): void;
+    post(path: string, route: RouteHandler | RouteDefinition): void;
+    put(path: string, route: RouteHandler | RouteDefinition): void;
+    patch(path: string, route: RouteHandler | RouteDefinition): void;
+    delete(path: string, route: RouteHandler | RouteDefinition): void;
+    head(path: string, route: RouteHandler | RouteDefinition): void;
+    options(path: string, route: RouteHandler | RouteDefinition): void;
+    group(prefix: string, configure: (router: IRouterApi) => void): void;
+    /**
+     * Finds the best matching route for the given method and path.
+     *
+     * Delegates to Hono's router for matching, then applies the kernel's own
+     * deterministic tie-break (§3.6 of M22 plan) when Hono returns multiple
+     * candidates of equal specificity.
+     *
+     * When multiple routes match, the ranking is:
+     *
+     * 1. more literal (static) segments;
+     * 2. then FEWER `*` wildcard segments;
+     * 3. then earliest registration order.
+     *
+     * The wildcard key is what makes an application catch-all lose to a route that
+     * names its path, in either registration order. Before M70g a `*` counted as a
+     * static segment, so `GET /*` tied with `GET /openapi.json` and won merely by
+     * registering first — which is how a full-stack application silently lost its
+     * OpenAPI endpoints.
+     *
+     * The rule compares COUNTS rather than comparing segment by segment, and that
+     * has one documented consequence: `/a/*` (one static, one wildcard) loses to
+     * `/:x/b` (one static, no wildcard) on a request for `/a/b`, where a
+     * per-position rule would prefer the literal `a`. That case is pinned by a test
+     * so a future change to per-segment ranking is a deliberate one.
+     *
+     * @param method - HTTP method
+     * @param path - Request path
+     * @returns The matched route entry and extracted params, or `null`
+     * @since 0.1.0
+     */
+    match(method: HttpMethod, path: string): {
+        definition: RouteDefinition;
+        params: Record<string, string>;
+        /** The selected entry — dispatch names the actual route node from its index. */
+        entry: RouteEntry;
+    } | null;
+    /**
+     * Returns all registered route entries, including the registration
+     * bookkeeping (`index`, `statics`, `wildcards`) that drives the tie-break.
+     *
+     * @returns The route entries in registration order
+     * @internal Test/diagnostics seam — `Router` is not exported from the package
+     * barrel, and plugins read routes through the contract's `listRoutes()`.
+     */
+    getAll(): readonly RouteEntry[];
+    listRoutes(): readonly RouteInfo[];
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/router/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/router/router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,eAAe,EACf,YAAY,EACZ,SAAS,EACV,MAAM,iBAAiB,CAAC;AAIzB,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,eAAe,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;OASG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,kEAAkE;IAClE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAwED,qBAAa,MAAO,YAAW,UAAU;;gBAS3B,KAAK,GAAE,MAAM,MAAM,GAAG,SAA2B;IAI7D;;;;;;OAMG;IACH,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI;IAoErF,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI;IAI9D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI;IAI/D,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI;IAI9D,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI;IAIhE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI;IAIjE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI;IAI/D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,GAAG,IAAI;IAIlE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI;IAIpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,KAAK,CACH,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,MAAM,GACX;QACD,UAAU,EAAE,eAAe,CAAC;QAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/B,gFAAgF;QAChF,KAAK,EAAE,UAAU,CAAC;KACnB,GAAG,IAAI;IA0FR;;;;;;;OAOG;IACH,MAAM,IAAI,SAAS,UAAU,EAAE;IAI/B,UAAU,IAAI,SAAS,SAAS,EAAE;CAQnC"}

package/dist/router/router.js

@@ -0,0 +1,350 @@
+import { parsePattern, staticSegmentCount, wildcardSegmentCount } from "./route-matcher.js";
+// Hono imports — use LinearRouter (not the default SmartRouter) because the
+// kernel's tie-break (§3.6) needs Hono to return EVERY overlapping candidate
+// for a path so it can re-rank them by static-segment count + registration
+// order. LinearRouter matches routes linearly and yields all candidates;
+// it also never raises RegExpRouter's UnsupportedPathError on overlapping
+// param patterns. Extracted params are strings either way.
+import { Hono } from 'hono';
+import { LinearRouter } from 'hono/router/linear-router';
+/**
+ * Programmatic router implementing {@linkcode IRouterApi}. Supports all 7
+ * HTTP verbs, route groups with prefix composition, and static-over-param
+ * matching preference.
+ *
+ * @since 0.3.0
+ */
+/**
+ * Key under which a route's {@linkcode RouteEntry} is carried on the stub
+ * handler Hono holds, so a match resolves the entry with a property read
+ * rather than a string key and a `Map` lookup on every request (M87).
+ */
+const ROUTE_ENTRY = Symbol('setu.router.entry');
+/** Shared empty params. Frozen, so a caller cannot mutate it into a shared surprise. */
+const EMPTY_PARAMS = Object.freeze({});
+/**
+ * Decodes Hono's raw (still percent-encoded) param values.
+ *
+ * Hono's low-level `router.match()` returns raw values — decoding normally
+ * happens in Hono's Context layer, which the kernel bypasses — so this
+ * preserves pre-M22 parity with the from-scratch matcher, which decoded per
+ * segment.
+ *
+ * Two allocations are avoided relative to the straightforward form (M87): a
+ * route with no params returns the shared frozen object rather than a fresh
+ * `{}`, and `decodeURIComponent` is skipped for a value containing no `%`,
+ * where it is an identity function (it does not decode `+`).
+ *
+ * @param raw - Hono's raw param record
+ * @returns The decoded params, or `null` when a value carries a malformed escape
+ */
+function decodeParams(raw) {
+    let params;
+    // `Object.keys`, not `for...in`: own enumerable properties only. Hono
+    // currently builds its params with a null prototype, so `for...in` happens
+    // to be equivalent — verified, not assumed — but that is an undocumented
+    // internal of a dependency, and if it ever became a `{}` literal a polluted
+    // `Object.prototype` would start injecting route params on every match. The
+    // `Object.entries` form this replaced was immune by construction; keeping
+    // that property costs nothing, since `keys` allocates one array where
+    // `entries` allocated one array plus a pair per key.
+    for (const key of Object.keys(raw)) {
+        const value = raw[key];
+        let decoded;
+        if (value.includes('%')) {
+            try {
+                decoded = decodeURIComponent(value);
+            }
+            catch {
+                return null;
+            }
+        }
+        else {
+            decoded = value;
+        }
+        (params ??= {})[key] = decoded;
+    }
+    return params ?? EMPTY_PARAMS;
+}
+export class Router {
+    #routes = [];
+    #index = 0;
+    #hono = new Hono({ strict: false, router: new LinearRouter() });
+    /** Maps `${method} ${path}` → the kernel's RouteEntry. */
+    #entryMap = new Map();
+    #owner;
+    #diagnosticsSink;
+    constructor(owner = () => undefined) {
+        this.#owner = owner;
+    }
+    /**
+     * Installs the diagnostics sink that receives route registration events at
+     * the owning mutation boundary. Pass `undefined` to detach (teardown).
+     *
+     * @param sink - The collector-facing sink, or `undefined`
+     * @since 0.8.0
+     */
+    setDiagnosticsSink(sink) {
+        this.#diagnosticsSink = sink;
+    }
+    #registerMethod(method, path, route) {
+        const key = `${method} ${path}`;
+        const existing = this.#entryMap.get(key);
+        if (existing !== undefined) {
+            // Name the FIRST claimant. The message used to give the pattern and the
+            // second claimant, which is the half the stack trace already carries; the
+            // half a developer needs is who got there first — `StaticPlugin` at the
+            // root collides with the SSR catch-all, and the old message named neither
+            // plugin. `owner` has carried this since M68.
+            throw new Error(`Route '${key}' is already registered by ${describeRouteOwner(existing)}.`);
+        }
+        const definition = typeof route === 'function' ? { handler: route } : route;
+        const owner = this.#owner();
+        const segments = parsePattern(path);
+        // Hoist per-request work to registration time (AI_GUIDELINES §14): parse
+        // the pattern once here and keep only the static count the tie-break reads.
+        const entry = {
+            pattern: path,
+            method,
+            definition,
+            index: this.#index++,
+            statics: staticSegmentCount(segments),
+            wildcards: wildcardSegmentCount(segments),
+            ...(owner === undefined ? {} : { owner }),
+        };
+        this.#routes.push(entry);
+        this.#entryMap.set(key, entry);
+        // Reported at the owning mutation boundary, after the entry exists — a
+        // duplicate-key refusal above never reaches this line.
+        this.#diagnosticsSink?.({
+            kind: 'register',
+            entryIndex: entry.index,
+            method,
+            pattern: path,
+            owner,
+            middlewareCount: definition.middleware?.length ?? 0,
+        });
+        // Register on Hono with a stub handler. The stub does NOT execute the
+        // framework handler — it exists only so Hono's matcher records the
+        // route and extracts params. The real handler runs through the custom
+        // pipeline + executeChain (§3.2 of M22 plan).
+        // Use `app.on()` for all methods (covers HEAD, OPTIONS which Hono
+        // doesn't expose as direct methods).
+        const stubHandler = (_c, _next) => {
+            // Stub — never called during matching.
+            return new Response();
+        };
+        // Carry the entry on the stub itself. Hono hands the handler back in the
+        // match tuple, so `match()` reads the entry with one property access
+        // instead of building a `${method} ${path}` key and consulting
+        // `#entryMap` on every request (M87). `#entryMap` remains the duplicate
+        // registration guard; this is a second, per-request-free route to the
+        // same object, not a second source of truth.
+        stubHandler[ROUTE_ENTRY] = entry;
+        this.#hono.on(method.toUpperCase(), path, stubHandler);
+    }
+    get(path, route) {
+        this.#registerMethod('GET', path, route);
+    }
+    post(path, route) {
+        this.#registerMethod('POST', path, route);
+    }
+    put(path, route) {
+        this.#registerMethod('PUT', path, route);
+    }
+    patch(path, route) {
+        this.#registerMethod('PATCH', path, route);
+    }
+    delete(path, route) {
+        this.#registerMethod('DELETE', path, route);
+    }
+    head(path, route) {
+        this.#registerMethod('HEAD', path, route);
+    }
+    options(path, route) {
+        this.#registerMethod('OPTIONS', path, route);
+    }
+    group(prefix, configure) {
+        configure(new GroupRouter(this, prefix));
+    }
+    /**
+     * Finds the best matching route for the given method and path.
+     *
+     * Delegates to Hono's router for matching, then applies the kernel's own
+     * deterministic tie-break (§3.6 of M22 plan) when Hono returns multiple
+     * candidates of equal specificity.
+     *
+     * When multiple routes match, the ranking is:
+     *
+     * 1. more literal (static) segments;
+     * 2. then FEWER `*` wildcard segments;
+     * 3. then earliest registration order.
+     *
+     * The wildcard key is what makes an application catch-all lose to a route that
+     * names its path, in either registration order. Before M70g a `*` counted as a
+     * static segment, so `GET /*` tied with `GET /openapi.json` and won merely by
+     * registering first — which is how a full-stack application silently lost its
+     * OpenAPI endpoints.
+     *
+     * The rule compares COUNTS rather than comparing segment by segment, and that
+     * has one documented consequence: `/a/*` (one static, one wildcard) loses to
+     * `/:x/b` (one static, no wildcard) on a request for `/a/b`, where a
+     * per-position rule would prefer the literal `a`. That case is pinned by a test
+     * so a future change to per-segment ranking is a deliberate one.
+     *
+     * @param method - HTTP method
+     * @param path - Request path
+     * @returns The matched route entry and extracted params, or `null`
+     * @since 0.1.0
+     */
+    match(method, path) {
+        // Delegate to Hono's router for matching.
+        // honoMatch shape: [[[handler, routeInfo], params], ...]
+        // honoMatch[0] is the flat array of candidates.
+        // Each candidate: [[handler, routeInfo], params] where routeInfo = {basePath, path, method}.
+        const honoMatch = this.#hono.router.match(method, path);
+        const candidatesRaw = honoMatch[0];
+        // Hono always returns honoMatch[0] as an array; early-return when empty
+        // covers the case where no routes are registered or nothing matches.
+        if (candidatesRaw.length === 0) {
+            return null;
+        }
+        // Fast path: exactly one candidate, which is every request in an
+        // application without overlapping patterns (M87). The candidates array,
+        // the per-candidate object literal and the sort below cannot change the
+        // outcome when there is nothing to tie-break against, so none of them is
+        // built. This mirrors Hono's own single-match bypass.
+        if (candidatesRaw.length === 1) {
+            const [handlerRouteTuple, rawParams] = candidatesRaw[0];
+            const entry = handlerRouteTuple[0][ROUTE_ENTRY];
+            const params = decodeParams(rawParams);
+            // A malformed escape means this route does not match, mirroring the
+            // multi-candidate path's `continue` when every candidate is dropped.
+            return params === null ? null : { definition: entry.definition, params, entry };
+        }
+        // Build candidates array: map each Hono candidate to the kernel RouteEntry.
+        // Hono always provides well-formed routeInfo/method/path on matched
+        // candidates, and every candidate maps back to #entryMap since we
+        // register both simultaneously with identical paths.
+        const candidates = [];
+        for (const [handlerRouteTuple, rawParams] of candidatesRaw) {
+            const routeInfo = handlerRouteTuple[1];
+            const routePath = routeInfo.path;
+            const routeMethod = routeInfo.method;
+            const entry = this.#entryMap.get(`${routeMethod} ${routePath}`);
+            // Same decoder as the single-candidate path above (M87 review). Keeping
+            // a second inline copy here let the two disagree on identity as well as
+            // duplicating the rule: this one built a fresh `{}` for a param-less
+            // route while the fast path returns the shared frozen object, so
+            // whether `params` was mutable depended on how many routes happened to
+            // match. A malformed escape means this candidate does not match,
+            // mirroring the old matcher's `null` return.
+            const params = decodeParams(rawParams);
+            if (params === null) {
+                continue;
+            }
+            candidates.push({ routePath, params, entry });
+        }
+        // Every candidate may have been dropped for a malformed param escape.
+        if (candidates.length === 0) {
+            return null;
+        }
+        // If only one candidate, return it directly.
+        if (candidates.length === 1) {
+            const { entry, params } = candidates[0];
+            return { definition: entry.definition, params, entry };
+        }
+        // Tie-break: more static segments, then fewer wildcards, then earliest
+        // registration order (§3.6 of the M22 plan, extended by M70g).
+        candidates.sort((a, b) => {
+            if (a.entry.statics !== b.entry.statics) {
+                return b.entry.statics - a.entry.statics;
+            }
+            if (a.entry.wildcards !== b.entry.wildcards) {
+                return a.entry.wildcards - b.entry.wildcards;
+            }
+            return a.entry.index - b.entry.index;
+        });
+        const best = candidates[0];
+        return { definition: best.entry.definition, params: best.params, entry: best.entry };
+    }
+    /**
+     * Returns all registered route entries, including the registration
+     * bookkeeping (`index`, `statics`, `wildcards`) that drives the tie-break.
+     *
+     * @returns The route entries in registration order
+     * @internal Test/diagnostics seam — `Router` is not exported from the package
+     * barrel, and plugins read routes through the contract's `listRoutes()`.
+     */
+    getAll() {
+        return this.#routes;
+    }
+    listRoutes() {
+        return this.#routes.map((entry) => ({
+            method: entry.method,
+            path: entry.pattern,
+            ...(entry.owner === undefined ? {} : { owner: entry.owner }),
+            definition: entry.definition,
+        }));
+    }
+}
+/**
+ * Names the party that registered a route, for the duplicate-route refusal.
+ *
+ * Module-private with one caller by design: the two arms exist so the message
+ * never says "registered by undefined", and a second call site would be a second
+ * place for that wording to drift.
+ *
+ * @param entry - The entry already holding the `METHOD path` key
+ * @returns `plugin 'name'` for a plugin-registered route, `the application` otherwise
+ */
+function describeRouteOwner(entry) {
+    return entry.owner === undefined ? 'the application' : `plugin '${entry.owner}'`;
+}
+/**
+ * Route group facade — prefixes every path registered inside the group
+ * callback. Nested groups compose prefixes transitively.
+ *
+ * @since 0.1.0
+ */
+class GroupRouter {
+    #parent;
+    #prefix;
+    constructor(parent, prefix) {
+        this.#parent = parent;
+        this.#prefix = prefix;
+    }
+    #resolvePath(path) {
+        // Normalize: ensure single slash between prefix and path
+        const p = path === '/' ? '' : path;
+        return this.#prefix + p;
+    }
+    get(path, route) {
+        this.#parent.get(this.#resolvePath(path), route);
+    }
+    post(path, route) {
+        this.#parent.post(this.#resolvePath(path), route);
+    }
+    put(path, route) {
+        this.#parent.put(this.#resolvePath(path), route);
+    }
+    patch(path, route) {
+        this.#parent.patch(this.#resolvePath(path), route);
+    }
+    delete(path, route) {
+        this.#parent.delete(this.#resolvePath(path), route);
+    }
+    head(path, route) {
+        this.#parent.head(this.#resolvePath(path), route);
+    }
+    options(path, route) {
+        this.#parent.options(this.#resolvePath(path), route);
+    }
+    group(prefix, configure) {
+        this.#parent.group(this.#prefix + prefix, configure);
+    }
+    listRoutes() {
+        return this.#parent.listRoutes();
+    }
+}
+//# sourceMappingURL=router.js.map

package/dist/router/router.js.map

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

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@setu-ts/kernel",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.10.0",
+  "description": "Capability-token plugin kernel: service registry, middleware pipeline, router",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/setu-ts/setu-ts.git",
+    "directory": "packages/kernel"
+  },
+  "homepage": "https://github.com/setu-ts/setu-ts/tree/main/packages/kernel",
+  "bugs": {
+    "url": "https://github.com/setu-ts/setu-ts/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": "^22.23.4 || ^24.22.1 || >=26.12.1"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE",
+    "AGENT_CARD.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@setu-ts/common": "^0.10.0",
+    "hono": "^4.12.30"
+  },
+  "devDependencies": {
+    "@setu-ts/exceptions": "^0.10.0",
+    "@setu-ts/logger-plugin": "^0.10.0",
+    "@setu-ts/runtime": "^0.10.0",
+    "@setu-ts/testing": "^0.10.0",
+    "@types/node": "^24",
+    "typescript": "6.0.3",
+    "vitest": "5.0.3"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  }
 }