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

package/dist/identity/service.js

@@ -4,8 +4,8 @@
  * Privacy-facing reads and mutations over the user identity graph:
  * fact listing/deletion, a full-identity data export, and the
  * memory-audit trail that records every mutation to a user's facts,
- * memories, and synthesized profile snapshot. Ported from Ignite's
- * `actions/identity.ts` (ADR-0008/ADR-0009 precedent — see
+ * memories, and synthesized profile snapshot. Ported from the first
+ * product's `actions/identity.ts` (ADR-0008/ADR-0009 precedent — see
  * `../documents/service.ts` and `../conversations/service.ts` for the
  * same move): the tables (`user_facts`, `user_memories`,
  * `user_profile_snapshots`, `user_memory_audit`) always lived in
@@ -16,11 +16,11 @@
  *
  * What did NOT come with it (stays product/agents-side):
  *   - `updateMyFactImportance` and the `synthesizeProfile()` re-trigger
- *     Ignite's `deleteMyFact` ran after deleting — synthesis is
- *     `@intelligo-dev/agents`' concern (deprecated, dissolving under
- *     ADR-0008), and this package cannot depend on it. `deleteFact`
- *     below does not touch the cached snapshot; a caller that also
- *     owns a synthesis engine re-triggers it after calling this.
+ *     the product's `deleteMyFact` ran after deleting — synthesis is
+ *     the product's AI code (ADR-0003), and this package cannot depend
+ *     on it. `deleteFact` below does not touch the cached snapshot; a
+ *     caller that also owns a synthesis engine re-triggers it after
+ *     calling this.
  *
  * Callers pass a resolved actor (workspaceId, userId) rather than this
  * module resolving one itself — `@intelligo-dev/core` cannot depend on
@@ -132,7 +132,7 @@ export async function deleteFact(actor, factId) {
  * Aggregate the actor's full identity graph — facts, memories, latest
  * profile snapshot, and full audit trail — for a data-export flow.
  * Records its own audit row (action "export"): the export operation
- * audits itself, same as the ported Ignite implementation.
+ * audits itself, same as the implementation it was ported from.
  */
 export async function exportIdentity(actor) {
     // Recorded before the reads so the export's own audit row is part of

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-export declare const version = "0.0.0";
 export * from "./db/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC;AAG/B,cAAc,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,cAAc,MAAM,CAAC"}

package/dist/index.js

@@ -1,4 +1,8 @@
-export const version = "0.0.0";
+// There was an `export const version = "0.0.0"` here, on a package
+// published as 1.0.0-beta.3, read by nothing. A version constant that
+// has to be kept in step with the manifest by hand will not be; the
+// manifest is the one place that cannot drift, and consumers who need
+// it can read it from there.
 // Re-export database client
 export * from "./db/index.js";
 // Email module -- use subpath import: @intelligo-dev/core/email

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC;AAE/B,4BAA4B;AAC5B,cAAc,MAAM,CAAC;AAErB,gEAAgE;AAChE,gFAAgF;AAChF,gFAAgF;AAChF,wEAAwE;AACxE,sEAAsE;AACtE,2DAA2D;AAC3D,qDAAqD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,sEAAsE;AACtE,oEAAoE;AACpE,sEAAsE;AACtE,6BAA6B;AAE7B,4BAA4B;AAC5B,cAAc,MAAM,CAAC;AAErB,gEAAgE;AAChE,gFAAgF;AAChF,gFAAgF;AAChF,wEAAwE;AACxE,sEAAsE;AACtE,2DAA2D;AAC3D,qDAAqD"}

package/dist/money.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Money, in one unit, with the currency attached.
+ *
+ * The framework used to denominate every amount in one deployment's
+ * currency: `balance_mnt`, `chargedMnt`, `estimatedMnt`, a
+ * `DEFAULT_USD_TO_MNT_RATE` constant, and a `formatPrice` that returned
+ * a tugrik glyph — in the public port types of a package meant to
+ * underpin products that do not sell in tugrik. This module is the
+ * replacement. It imports nothing, and must keep importing nothing:
+ * `@intelligo-dev/executions/pricing` is a deliberate zero-import leaf
+ * that client bundles reach, and it needs these types without dragging
+ * the rest of core behind them. `core/registry` holds the same line for
+ * the same reason.
+ *
+ * Two decisions worth stating, because both look arbitrary and neither
+ * is.
+ *
+ * **Micros, not minor units.** A typical chat turn on a cheap model
+ * costs about $0.0019 of provider time, which is 0.74 cents once the
+ * margin is applied. Rounding that to whole cents overcharges by more
+ * than a third on every request. Six decimal places was in fact what
+ * the old `× 3450` tugrik scaling bought — this keeps the precision and
+ * drops the pretence that the number is a currency.
+ *
+ * **Currency on the amount, not in a global.** The bug this is built
+ * against was a credit pack whose grant was authored in tokens and
+ * spent as ledger units: 100,000 of one unit sold for $1.01 of another.
+ * Nothing in the type system objected, because the number was a
+ * `number`. Here the currency travels with the amount and `add` refuses
+ * to mix two.
+ */
+declare const isoTag: unique symbol;
+declare const microsTag: unique symbol;
+/** An ISO-4217 alphabetic code, upper-cased and validated. */
+export type CurrencyCode = string & {
+    readonly [isoTag]: true;
+};
+/** An integer number of millionths of one major currency unit. */
+export type Micros = number & {
+    readonly [microsTag]: true;
+};
+/** An amount and the currency it is denominated in. */
+export type Money = {
+    readonly amount: Micros;
+    readonly currency: CurrencyCode;
+};
+/** Thrown for every misuse in this module, so callers can catch one type. */
+export declare class MoneyError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/**
+ * Validate and normalise an ISO-4217 code.
+ *
+ * Shape only — a real registry would go stale, and a deployment
+ * selling in a code this file has never heard of should not be blocked
+ * by a list. `minorExponent` is where an unknown code takes its
+ * conservative default.
+ */
+export declare function currency(code: string): CurrencyCode;
+/**
+ * An integer count of micros.
+ *
+ * The upper bound is `Number.MAX_SAFE_INTEGER`, which at six decimal
+ * places is about 9 billion major units — far above any real balance,
+ * and low enough to catch a value that arrived in the wrong unit.
+ */
+export declare function micros(value: number): Micros;
+export declare function money(amount: number, code: string | CurrencyCode): Money;
+/** How many decimal places this currency's minor unit has. */
+export declare function minorExponent(code: CurrencyCode): 0 | 2 | 3;
+/** `12.34` USD → `12_340_000` micros. */
+export declare function fromMajor(value: number, code: string | CurrencyCode): Money;
+/** `1234` cents → `12_340_000` micros. */
+export declare function fromMinor(value: number, code: string | CurrencyCode): Money;
+/**
+ * The integer a payment provider wants: whole units for a zero-decimal
+ * currency, hundredths for most, thousandths for a few.
+ *
+ * Rounds up. A fraction of a minor unit is money the deployment has
+ * already spent, and rounding it away means eating the difference on
+ * every transaction.
+ */
+export declare function toMinor(value: Money): number;
+/** The amount as a plain decimal number, for display and for charts. */
+export declare function toMajor(value: Money): number;
+export declare const zero: (code: string | CurrencyCode) => Money;
+export declare function add(a: Money, b: Money): Money;
+export declare function subtract(a: Money, b: Money): Money;
+/** Scale by a plain factor — a margin multiplier, a percentage, a count. */
+export declare function multiply(value: Money, factor: number): Money;
+export declare function compare(a: Money, b: Money): number;
+export declare const isZero: (value: Money) => boolean;
+export declare const isNegative: (value: Money) => boolean;
+/**
+ * Convert at an explicit rate, expressed in micros so the rate itself
+ * carries no float error: `3_450_000_000` is 3450.0.
+ *
+ * There is no ambient rate and no default. A framework that guesses an
+ * exchange rate is inventing money.
+ */
+export declare function convert(value: Money, to: string | CurrencyCode, rateMicros: number): Money;
+/**
+ * Format for a human, in their locale.
+ *
+ * `Intl` owns the symbol, its position, the grouping separator and the
+ * decimal separator — none of which belong in framework source. This
+ * is the function that replaces a `₮${n.toLocaleString()}` template.
+ */
+export declare function formatMoney(value: Money, locale: string, options?: Intl.NumberFormatOptions): string;
+export {};
+//# sourceMappingURL=money.d.ts.map

package/dist/money.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../src/money.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,CAAC,MAAM,MAAM,EAAE,OAAO,MAAM,CAAC;AACpC,OAAO,CAAC,MAAM,SAAS,EAAE,OAAO,MAAM,CAAC;AAEvC,8DAA8D;AAC9D,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAEhE,kEAAkE;AAClE,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAE7D,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;CACjC,CAAC;AAEF,6EAA6E;AAC7E,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBACV,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK1C;AAyCD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CASnD;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAc5C;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK,CAExE;AAED,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAE3D;AAED,yCAAyC;AACzC,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK,CAK3E;AAED,0CAA0C;AAC1C,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK,CAI3E;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAG5C;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAE5C;AAED,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,GAAG,YAAY,KAAG,KAGjD,CAAC;AAWH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAG7C;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAGlD;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAQ5D;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CAGlD;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,KAAG,OAA6B,CAAC;AACpE,eAAO,MAAM,UAAU,GAAI,OAAO,KAAK,KAAG,OAA2B,CAAC;AAEtE;;;;;;GAMG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,KAAK,EACZ,EAAE,EAAE,MAAM,GAAG,YAAY,EACzB,UAAU,EAAE,MAAM,GACjB,KAAK,CAqBP;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,IAAI,CAAC,mBAAwB,GACrC,MAAM,CASR"}

package/dist/money.js

@@ -0,0 +1,217 @@
+/**
+ * Money, in one unit, with the currency attached.
+ *
+ * The framework used to denominate every amount in one deployment's
+ * currency: `balance_mnt`, `chargedMnt`, `estimatedMnt`, a
+ * `DEFAULT_USD_TO_MNT_RATE` constant, and a `formatPrice` that returned
+ * a tugrik glyph — in the public port types of a package meant to
+ * underpin products that do not sell in tugrik. This module is the
+ * replacement. It imports nothing, and must keep importing nothing:
+ * `@intelligo-dev/executions/pricing` is a deliberate zero-import leaf
+ * that client bundles reach, and it needs these types without dragging
+ * the rest of core behind them. `core/registry` holds the same line for
+ * the same reason.
+ *
+ * Two decisions worth stating, because both look arbitrary and neither
+ * is.
+ *
+ * **Micros, not minor units.** A typical chat turn on a cheap model
+ * costs about $0.0019 of provider time, which is 0.74 cents once the
+ * margin is applied. Rounding that to whole cents overcharges by more
+ * than a third on every request. Six decimal places was in fact what
+ * the old `× 3450` tugrik scaling bought — this keeps the precision and
+ * drops the pretence that the number is a currency.
+ *
+ * **Currency on the amount, not in a global.** The bug this is built
+ * against was a credit pack whose grant was authored in tokens and
+ * spent as ledger units: 100,000 of one unit sold for $1.01 of another.
+ * Nothing in the type system objected, because the number was a
+ * `number`. Here the currency travels with the amount and `add` refuses
+ * to mix two.
+ */
+/** Thrown for every misuse in this module, so callers can catch one type. */
+export class MoneyError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "MoneyError";
+    }
+}
+const MICROS_PER_UNIT = 1000000;
+/**
+ * Currencies whose minor unit is not the usual hundredth.
+ *
+ * Only the exceptions are listed; everything else is 2. Getting this
+ * wrong is not cosmetic — it is the difference between charging ¥1,000
+ * and ¥100,000, because Stripe takes zero-decimal currencies in whole
+ * units and every other one in hundredths.
+ */
+const MINOR_EXPONENT = {
+    BIF: 0,
+    CLP: 0,
+    DJF: 0,
+    GNF: 0,
+    ISK: 0,
+    JPY: 0,
+    KMF: 0,
+    KRW: 0,
+    MGA: 0,
+    MNT: 0,
+    PYG: 0,
+    RWF: 0,
+    UGX: 0,
+    UYI: 0,
+    VND: 0,
+    VUV: 0,
+    XAF: 0,
+    XOF: 0,
+    XPF: 0,
+    BHD: 3,
+    IQD: 3,
+    JOD: 3,
+    KWD: 3,
+    LYD: 3,
+    OMR: 3,
+    TND: 3,
+};
+/**
+ * Validate and normalise an ISO-4217 code.
+ *
+ * Shape only — a real registry would go stale, and a deployment
+ * selling in a code this file has never heard of should not be blocked
+ * by a list. `minorExponent` is where an unknown code takes its
+ * conservative default.
+ */
+export function currency(code) {
+    const upper = code.toUpperCase();
+    if (!/^[A-Z]{3}$/.test(upper)) {
+        throw new MoneyError("invalid_currency", `"${code}" is not an ISO-4217 alphabetic code (three letters).`);
+    }
+    return upper;
+}
+/**
+ * An integer count of micros.
+ *
+ * The upper bound is `Number.MAX_SAFE_INTEGER`, which at six decimal
+ * places is about 9 billion major units — far above any real balance,
+ * and low enough to catch a value that arrived in the wrong unit.
+ */
+export function micros(value) {
+    if (!Number.isInteger(value)) {
+        throw new MoneyError("not_an_integer", `Micros must be a whole number; received ${value}. Convert with fromMajor/fromMinor rather than multiplying by hand.`);
+    }
+    if (!Number.isSafeInteger(value)) {
+        throw new MoneyError("out_of_range", `${value} micros exceeds the safe integer range.`);
+    }
+    return value;
+}
+export function money(amount, code) {
+    return { amount: micros(amount), currency: currency(code) };
+}
+/** How many decimal places this currency's minor unit has. */
+export function minorExponent(code) {
+    return MINOR_EXPONENT[code] ?? 2;
+}
+/** `12.34` USD → `12_340_000` micros. */
+export function fromMajor(value, code) {
+    return {
+        amount: micros(Math.round(value * MICROS_PER_UNIT)),
+        currency: currency(code),
+    };
+}
+/** `1234` cents → `12_340_000` micros. */
+export function fromMinor(value, code) {
+    const c = currency(code);
+    const scale = MICROS_PER_UNIT / 10 ** minorExponent(c);
+    return { amount: micros(Math.round(value * scale)), currency: c };
+}
+/**
+ * The integer a payment provider wants: whole units for a zero-decimal
+ * currency, hundredths for most, thousandths for a few.
+ *
+ * Rounds up. A fraction of a minor unit is money the deployment has
+ * already spent, and rounding it away means eating the difference on
+ * every transaction.
+ */
+export function toMinor(value) {
+    const scale = MICROS_PER_UNIT / 10 ** minorExponent(value.currency);
+    return Math.ceil(value.amount / scale);
+}
+/** The amount as a plain decimal number, for display and for charts. */
+export function toMajor(value) {
+    return value.amount / MICROS_PER_UNIT;
+}
+export const zero = (code) => ({
+    amount: 0,
+    currency: currency(code),
+});
+function sameCurrency(a, b, op) {
+    if (a.currency !== b.currency) {
+        throw new MoneyError("currency_mismatch", `Cannot ${op} ${a.currency} and ${b.currency}. Convert one first — an exchange rate is a decision, not a coercion.`);
+    }
+}
+export function add(a, b) {
+    sameCurrency(a, b, "add");
+    return { amount: micros(a.amount + b.amount), currency: a.currency };
+}
+export function subtract(a, b) {
+    sameCurrency(a, b, "subtract");
+    return { amount: micros(a.amount - b.amount), currency: a.currency };
+}
+/** Scale by a plain factor — a margin multiplier, a percentage, a count. */
+export function multiply(value, factor) {
+    if (!Number.isFinite(factor)) {
+        throw new MoneyError("invalid_factor", `Factor must be finite.`);
+    }
+    return {
+        amount: micros(Math.ceil(value.amount * factor)),
+        currency: value.currency,
+    };
+}
+export function compare(a, b) {
+    sameCurrency(a, b, "compare");
+    return a.amount === b.amount ? 0 : a.amount < b.amount ? -1 : 1;
+}
+export const isZero = (value) => value.amount === 0;
+export const isNegative = (value) => value.amount < 0;
+/**
+ * Convert at an explicit rate, expressed in micros so the rate itself
+ * carries no float error: `3_450_000_000` is 3450.0.
+ *
+ * There is no ambient rate and no default. A framework that guesses an
+ * exchange rate is inventing money.
+ */
+export function convert(value, to, rateMicros) {
+    const target = currency(to);
+    if (!Number.isInteger(rateMicros) || rateMicros <= 0) {
+        throw new MoneyError("invalid_rate", `Rate must be a positive integer number of micros; received ${rateMicros}.`);
+    }
+    if (target === value.currency) {
+        if (rateMicros !== MICROS_PER_UNIT) {
+            throw new MoneyError("invalid_rate", `Converting ${value.currency} to itself at ${rateMicros / MICROS_PER_UNIT} is not a conversion.`);
+        }
+        return value;
+    }
+    return {
+        amount: micros(Math.ceil((value.amount * rateMicros) / MICROS_PER_UNIT)),
+        currency: target,
+    };
+}
+/**
+ * Format for a human, in their locale.
+ *
+ * `Intl` owns the symbol, its position, the grouping separator and the
+ * decimal separator — none of which belong in framework source. This
+ * is the function that replaces a `₮${n.toLocaleString()}` template.
+ */
+export function formatMoney(value, locale, options = {}) {
+    const digits = minorExponent(value.currency);
+    return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: value.currency,
+        minimumFractionDigits: digits,
+        maximumFractionDigits: digits,
+        ...options,
+    }).format(toMajor(value));
+}
+//# sourceMappingURL=money.js.map

package/dist/money.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.js","sourceRoot":"","sources":["../src/money.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAiBH,6EAA6E;AAC7E,MAAM,OAAO,UAAW,SAAQ,KAAK;IAEnC,YAAY,IAAY,EAAE,OAAe;QACvC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAED,MAAM,eAAe,GAAG,OAAS,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,cAAc,GAAwC;IAC1D,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;CACP,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACjC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,UAAU,CAClB,kBAAkB,EAClB,IAAI,IAAI,uDAAuD,CAChE,CAAC;IACJ,CAAC;IACD,OAAO,KAAqB,CAAC;AAC/B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CAAC,KAAa;IAClC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,UAAU,CAClB,gBAAgB,EAChB,2CAA2C,KAAK,qEAAqE,CACtH,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,UAAU,CAClB,cAAc,EACd,GAAG,KAAK,yCAAyC,CAClD,CAAC;IACJ,CAAC;IACD,OAAO,KAAe,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,MAAc,EAAE,IAA2B;IAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;AAC9D,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,aAAa,CAAC,IAAkB;IAC9C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,yCAAyC;AACzC,MAAM,UAAU,SAAS,CAAC,KAAa,EAAE,IAA2B;IAClE,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,eAAe,CAAC,CAAC;QACnD,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC;KACzB,CAAC;AACJ,CAAC;AAED,0CAA0C;AAC1C,MAAM,UAAU,SAAS,CAAC,KAAa,EAAE,IAA2B;IAClE,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IACzB,MAAM,KAAK,GAAG,eAAe,GAAG,EAAE,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;IACvD,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;AACpE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CAAC,KAAY;IAClC,MAAM,KAAK,GAAG,eAAe,GAAG,EAAE,IAAI,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACpE,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;AACzC,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,OAAO,CAAC,KAAY;IAClC,OAAO,KAAK,CAAC,MAAM,GAAG,eAAe,CAAC;AACxC,CAAC;AAED,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,IAA2B,EAAS,EAAE,CAAC,CAAC;IAC3D,MAAM,EAAE,CAAW;IACnB,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC;CACzB,CAAC,CAAC;AAEH,SAAS,YAAY,CAAC,CAAQ,EAAE,CAAQ,EAAE,EAAU;IAClD,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC9B,MAAM,IAAI,UAAU,CAClB,mBAAmB,EACnB,UAAU,EAAE,IAAI,CAAC,CAAC,QAAQ,QAAQ,CAAC,CAAC,QAAQ,uEAAuE,CACpH,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,GAAG,CAAC,CAAQ,EAAE,CAAQ;IACpC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IAC1B,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;AACvE,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,CAAQ,EAAE,CAAQ;IACzC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;AACvE,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,QAAQ,CAAC,KAAY,EAAE,MAAc;IACnD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,UAAU,CAAC,gBAAgB,EAAE,wBAAwB,CAAC,CAAC;IACnE,CAAC;IACD,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;QAChD,QAAQ,EAAE,KAAK,CAAC,QAAQ;KACzB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,CAAQ,EAAE,CAAQ;IACxC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;IAC9B,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClE,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAY,EAAW,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AACpE,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAY,EAAW,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CACrB,KAAY,EACZ,EAAyB,EACzB,UAAkB;IAElB,MAAM,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC5B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,UAAU,IAAI,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,UAAU,CAClB,cAAc,EACd,8DAA8D,UAAU,GAAG,CAC5E,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,KAAK,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,UAAU,KAAK,eAAe,EAAE,CAAC;YACnC,MAAM,IAAI,UAAU,CAClB,cAAc,EACd,cAAc,KAAK,CAAC,QAAQ,iBAAiB,UAAU,GAAG,eAAe,uBAAuB,CACjG,CAAC;QACJ,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC,GAAG,eAAe,CAAC,CAAC;QACxE,QAAQ,EAAE,MAAM;KACjB,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CACzB,KAAY,EACZ,MAAc,EACd,UAAoC,EAAE;IAEtC,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC7C,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE;QACnC,KAAK,EAAE,UAAU;QACjB,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,qBAAqB,EAAE,MAAM;QAC7B,qBAAqB,EAAE,MAAM;QAC7B,GAAG,OAAO;KACX,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AAC5B,CAAC"}

package/dist/registry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+/**
+ * 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 declare function createRegistry<T>(key: string): Map<string, T>;
+/**
+ * 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 declare function createRegistryRef<T>(key: string, initial: T): {
+    get(): T;
+    set(value: T): void;
+};
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAWH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CA2B7D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,GACT;IAAE,GAAG,IAAI,CAAC,CAAC;IAAC,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAA;CAAE,CASnC"}

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"}