@intelligo-dev/core 1.0.0-beta.3 → 1.0.0-beta.6

package/dist/registry.js

@@ -0,0 +1,92 @@
+/**
+ * Registries that survive a bundler duplicating the module they live in.
+ *
+ * A framework registry is a `Map` at module scope: the composition root
+ * writes to it once at startup and every later reader reads through it.
+ * That holds exactly as long as there is one instance of the module.
+ * Next.js does not guarantee that — its server build splits code into
+ * several bundles, and a package imported from two of them can be
+ * instantiated twice. The composition root then writes to one copy and
+ * a page reads the other.
+ *
+ * The failure is quiet, which is what makes it expensive. The first
+ * product to hit it saw `"No billing product configured"` logged by a
+ * page that rendered perfectly well: quota state came back null,
+ * feature checks fell through to their closed defaults, and nothing
+ * threw. Its workaround was a `server-only` side-effect module that
+ * every server file had to import, plus an architecture test naming the
+ * ten functions that read a registry — ADR-0005 forbids exactly that
+ * kind of import-side-effect registration, so the product had to
+ * violate the rule inside files the framework had shipped it.
+ *
+ * Keying the storage off `Symbol.for()` moves the map out of the module
+ * and into the realm's global symbol registry, which the bundler cannot
+ * duplicate. Every copy of the module then finds the same map, and the
+ * composition root can go back to running once.
+ *
+ * The limit, stated honestly: `globalThis` is per process. Node and
+ * Edge runtimes are separate processes and each still needs the
+ * composition root to run. This fixes duplicate modules, not duplicate
+ * runtimes.
+ */
+const seen = new Set();
+/**
+ * A `Map` shared by every copy of the module that asks for the same
+ * key.
+ *
+ * Use it wherever a registry is written by the composition root and
+ * read by request-time code:
+ *
+ *     const plans = createRegistry<PlanMap>("billing/plans");
+ *
+ * `key` is namespaced into the global symbol registry, so it needs to
+ * be unique across the framework — `"<package>/<registry>"` is the
+ * convention. The value type is not checked across copies: two modules
+ * that disagree about `T` for one key is a programming error this
+ * cannot catch, which is why the keys live next to their registries
+ * rather than in a shared list someone could reuse by accident.
+ */
+export function createRegistry(key) {
+    const symbol = Symbol.for(`@intelligo-dev/registry/${key}`);
+    const globals = globalThis;
+    const existing = globals[symbol];
+    if (existing) {
+        // A second copy of the module reaching the same slot is the
+        // condition this function exists to survive — it is not an error,
+        // and the map it returns is the right one. It is worth saying once
+        // per key, because it also means every *other* module-scope value
+        // in that file is duplicated too, and the next one to matter will
+        // not announce itself.
+        if (existing.origin !== import.meta.url && !seen.has(key)) {
+            seen.add(key);
+            console.warn(`[intelligo] registry "${key}" is being read from a second module ` +
+                `instance (${import.meta.url}, first seen from ${existing.origin}). ` +
+                `The registry itself is shared, so this is safe — but any other ` +
+                `module-scope state in that file is now duplicated.`);
+        }
+        return existing.map;
+    }
+    const map = new Map();
+    globals[symbol] = { map, origin: import.meta.url };
+    return map;
+}
+/**
+ * A single shared value, for the registries that are not maps.
+ *
+ * `defaultProductSlug` is the one that motivated this: a `let` at
+ * module scope has exactly the duplication problem a `Map` does, and
+ * it is the value whose absence produces "No billing product
+ * configured".
+ */
+export function createRegistryRef(key, initial) {
+    const box = createRegistry(`ref/${key}`);
+    if (!box.has("value"))
+        box.set("value", initial);
+    return {
+        get: () => box.get("value"),
+        set: (value) => {
+            box.set("value", value);
+        },
+    };
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AASH,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;AAE/B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,cAAc,CAAI,GAAW;IAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,2BAA2B,GAAG,EAAE,CAAC,CAAC;IAC5D,MAAM,OAAO,GAAG,UAA4D,CAAC;IAE7E,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,IAAI,QAAQ,EAAE,CAAC;QACb,4DAA4D;QAC5D,kEAAkE;QAClE,mEAAmE;QACnE,kEAAkE;QAClE,kEAAkE;QAClE,uBAAuB;QACvB,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1D,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,OAAO,CAAC,IAAI,CACV,yBAAyB,GAAG,uCAAuC;gBACjE,aAAa,MAAM,CAAC,IAAI,CAAC,GAAG,qBAAqB,QAAQ,CAAC,MAAM,KAAK;gBACrE,iEAAiE;gBACjE,oDAAoD,CACvD,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC;IACtB,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,GAAG,EAAa,CAAC;IACjC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IACnD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,GAAW,EACX,OAAU;IAEV,MAAM,GAAG,GAAG,cAAc,CAAI,OAAO,GAAG,EAAE,CAAC,CAAC;IAC5C,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC;QAAE,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACjD,OAAO;QACL,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAM;QAChC,GAAG,EAAE,CAAC,KAAQ,EAAE,EAAE;YAChB,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC1B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/request-context.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Where request-scoped context comes from.
+ *
+ * `@intelligo-dev/auth` needs the incoming request's headers to resolve
+ * a session, and it got them by importing `next/headers` directly in
+ * five files. That made a package whose subject is authentication —
+ * not rendering — unusable outside Next: a queue worker that wants to
+ * check a session, a Hono API, a product on another framework, a test
+ * that is not running inside a request. ADR-0005 named the fix in its
+ * consequences; this is it.
+ *
+ * The framework asks for headers through `getRequestHeaders()`. The
+ * application says where they come from, once, from its composition
+ * root:
+ *
+ *     import { setRequestContextSource } from "@intelligo-dev/core/request-context";
+ *     import { nextRequestContext } from "@intelligo-dev/next";
+ *
+ *     setRequestContextSource(nextRequestContext);
+ *
+ * `@intelligo-dev/next` is the only package in the framework that
+ * imports `next/*`, and an architecture test keeps it that way. This
+ * module imports nothing but `./registry`, so the contract is reachable
+ * from any runtime the adapter is not.
+ *
+ * Nothing self-registers. An unbound source throws where the headers
+ * are needed, naming the two lines that fix it — the alternative is a
+ * framework that guesses at the request, which is how a session gets
+ * read from the wrong one.
+ */
+/**
+ * Produces the current request's headers.
+ *
+ * Async because Next's accessor is, and sync sources satisfy it too —
+ * `getRequestHeaders` awaits either.
+ */
+export type RequestContextSource = () => Headers | Promise<Headers>;
+export declare class RequestContextUnavailableError extends Error {
+    readonly code = "request_context_unavailable";
+    constructor();
+}
+export declare function setRequestContextSource(next: RequestContextSource): void;
+/** Forget the bound source. For tests composing a fresh root. */
+export declare function clearRequestContextSource(): void;
+export declare function hasRequestContextSource(): boolean;
+/**
+ * The current request's headers.
+ *
+ * @throws {RequestContextUnavailableError} when nothing is bound.
+ */
+export declare function getRequestHeaders(): Promise<Headers>;
+/**
+ * Run `fn` with these headers, whatever the ambient source says.
+ *
+ * For the callers that have a request but are not inside the
+ * framework's request scope: a background job replaying a webhook, a
+ * script acting as a user, an integration test that wants a real
+ * session without a server. Restores the previous value afterwards, so
+ * nesting behaves.
+ *
+ * Not `AsyncLocalStorage`: the value is set and restored around one
+ * awaited call, and ALS would make the package require a Node built-in
+ * that Edge runtimes only partly provide.
+ */
+export declare function withRequestHeaders<T>(headers: Headers, fn: () => Promise<T> | T): Promise<T>;
+//# sourceMappingURL=request-context.d.ts.map

package/dist/request-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../src/request-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEpE,qBAAa,8BAA+B,SAAQ,KAAK;IACvD,QAAQ,CAAC,IAAI,iCAAiC;;CAU/C;AAmBD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAExE;AAED,iEAAiE;AACjE,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD;AAED,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAO1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,OAAO,EAAE,OAAO,EAChB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACvB,OAAO,CAAC,CAAC,CAAC,CAQZ"}

package/dist/request-context.js

@@ -0,0 +1,99 @@
+/**
+ * Where request-scoped context comes from.
+ *
+ * `@intelligo-dev/auth` needs the incoming request's headers to resolve
+ * a session, and it got them by importing `next/headers` directly in
+ * five files. That made a package whose subject is authentication —
+ * not rendering — unusable outside Next: a queue worker that wants to
+ * check a session, a Hono API, a product on another framework, a test
+ * that is not running inside a request. ADR-0005 named the fix in its
+ * consequences; this is it.
+ *
+ * The framework asks for headers through `getRequestHeaders()`. The
+ * application says where they come from, once, from its composition
+ * root:
+ *
+ *     import { setRequestContextSource } from "@intelligo-dev/core/request-context";
+ *     import { nextRequestContext } from "@intelligo-dev/next";
+ *
+ *     setRequestContextSource(nextRequestContext);
+ *
+ * `@intelligo-dev/next` is the only package in the framework that
+ * imports `next/*`, and an architecture test keeps it that way. This
+ * module imports nothing but `./registry`, so the contract is reachable
+ * from any runtime the adapter is not.
+ *
+ * Nothing self-registers. An unbound source throws where the headers
+ * are needed, naming the two lines that fix it — the alternative is a
+ * framework that guesses at the request, which is how a session gets
+ * read from the wrong one.
+ */
+import { createRegistryRef } from "./registry.js";
+export class RequestContextUnavailableError extends Error {
+    constructor() {
+        super("No request context source is bound. Call setRequestContextSource() " +
+            "from your composition root — `nextRequestContext` from " +
+            "@intelligo-dev/next in a Next.js app — or wrap the call in " +
+            "withRequestHeaders() outside a request.");
+        this.code = "request_context_unavailable";
+        this.name = "RequestContextUnavailableError";
+    }
+}
+/**
+ * Held in the cross-instance registry rather than a module variable
+ * for the same reason every other framework registry is: a bundler
+ * that duplicates this module would otherwise give the composition
+ * root one copy and the request path another.
+ */
+const source = createRegistryRef("core/request-context-source", undefined);
+/** Explicitly bound headers, for a call that is not inside a request. */
+const override = createRegistryRef("core/request-headers-override", undefined);
+export function setRequestContextSource(next) {
+    source.set(next);
+}
+/** Forget the bound source. For tests composing a fresh root. */
+export function clearRequestContextSource() {
+    source.set(undefined);
+    override.set(undefined);
+}
+export function hasRequestContextSource() {
+    return source.get() !== undefined || override.get() !== undefined;
+}
+/**
+ * The current request's headers.
+ *
+ * @throws {RequestContextUnavailableError} when nothing is bound.
+ */
+export async function getRequestHeaders() {
+    const explicit = override.get();
+    if (explicit)
+        return explicit;
+    const resolve = source.get();
+    if (!resolve)
+        throw new RequestContextUnavailableError();
+    return await resolve();
+}
+/**
+ * Run `fn` with these headers, whatever the ambient source says.
+ *
+ * For the callers that have a request but are not inside the
+ * framework's request scope: a background job replaying a webhook, a
+ * script acting as a user, an integration test that wants a real
+ * session without a server. Restores the previous value afterwards, so
+ * nesting behaves.
+ *
+ * Not `AsyncLocalStorage`: the value is set and restored around one
+ * awaited call, and ALS would make the package require a Node built-in
+ * that Edge runtimes only partly provide.
+ */
+export async function withRequestHeaders(headers, fn) {
+    const previous = override.get();
+    override.set(headers);
+    try {
+        return await fn();
+    }
+    finally {
+        override.set(previous);
+    }
+}
+//# sourceMappingURL=request-context.js.map

package/dist/request-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.js","sourceRoot":"","sources":["../src/request-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAU/C,MAAM,OAAO,8BAA+B,SAAQ,KAAK;IAEvD;QACE,KAAK,CACH,qEAAqE;YACnE,yDAAyD;YACzD,6DAA6D;YAC7D,yCAAyC,CAC5C,CAAC;QAPK,SAAI,GAAG,6BAA6B,CAAC;QAQ5C,IAAI,CAAC,IAAI,GAAG,gCAAgC,CAAC;IAC/C,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,MAAM,GAAG,iBAAiB,CAC9B,6BAA6B,EAC7B,SAAS,CACV,CAAC;AAEF,yEAAyE;AACzE,MAAM,QAAQ,GAAG,iBAAiB,CAChC,+BAA+B,EAC/B,SAAS,CACV,CAAC;AAEF,MAAM,UAAU,uBAAuB,CAAC,IAA0B;IAChE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACnB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,yBAAyB;IACvC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,UAAU,uBAAuB;IACrC,OAAO,MAAM,CAAC,GAAG,EAAE,KAAK,SAAS,IAAI,QAAQ,CAAC,GAAG,EAAE,KAAK,SAAS,CAAC;AACpE,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC;IAChC,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAE9B,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC;IAC7B,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,8BAA8B,EAAE,CAAC;IACzD,OAAO,MAAM,OAAO,EAAE,CAAC;AACzB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,OAAgB,EAChB,EAAwB;IAExB,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACtB,IAAI,CAAC;QACH,OAAO,MAAM,EAAE,EAAE,CAAC;IACpB,CAAC;YAAS,CAAC;QACT,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACzB,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intelligo-dev/core",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.6",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -49,6 +49,22 @@
       "types": "./dist/env.d.ts",
       "default": "./dist/env.js"
     },
+    "./registry": {
+      "types": "./dist/registry.d.ts",
+      "default": "./dist/registry.js"
+    },
+    "./money": {
+      "types": "./dist/money.d.ts",
+      "default": "./dist/money.js"
+    },
+    "./request-context": {
+      "types": "./dist/request-context.d.ts",
+      "default": "./dist/request-context.js"
+    },
+    "./prompt": {
+      "types": "./dist/prompt.d.ts",
+      "default": "./dist/prompt.js"
+    },
     "./logger": {
       "types": "./dist/logger.d.ts",
       "import": "./dist/logger.js",
@@ -59,16 +75,14 @@
     "@neondatabase/serverless": "^0.10.4",
     "@react-email/components": "^1.0.7",
     "dotenv": "^16.4.7",
-    "drizzle-orm": "^0.45.1",
     "pg": "^8.18.0",
     "pino": "^10.3.1",
-    "react": "^19.0.0",
-    "resend": "^6.9.1",
-    "server-only": "^0.0.1",
-    "zod": "^3.24.1"
+    "resend": "^6.9.1"
   },
   "peerDependencies": {
-    "next": "^15.0.0 || ^16.0.0"
+    "drizzle-orm": "^0.45.1",
+    "react": "^19.0.0",
+    "zod": "^3.24.1"
   },
   "devDependencies": {
     "@types/bcryptjs": "^3.0.0",
@@ -76,18 +90,33 @@
     "@types/react": "^19.0.10",
     "bcryptjs": "^3.0.3",
     "drizzle-kit": "^0.31.8",
+    "drizzle-orm": "^0.45.1",
     "next": "^16.0.7",
     "pino-pretty": "^13.1.3",
+    "react": "^19.0.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "zod": "^3.24.1"
   },
   "files": [
     "dist",
-    "src/db/migrations"
+    "src/db/migrations",
+    "LICENSE",
+    "README.md",
+    "!dist/**/*.tsbuildinfo"
   ],
   "publishConfig": {
     "access": "public"
   },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "sideEffects": false,
   "scripts": {
     "type-check": "tsc --noEmit",
     "lint": "eslint .",