@endora-commerce/platform 0.100.0

package/dist/db/orm.d.ts

@@ -0,0 +1,40 @@
+import { MikroORM } from '@mikro-orm/postgresql';
+import type { Options } from '@mikro-orm/postgresql';
+/**
+ * Thin ORM bootstrap wrapper.
+ *
+ * `initOrm()` boots MikroORM once and caches it; `getOrm()` returns it;
+ * `closeOrm()` disposes it. That is the whole surface.
+ *
+ * **`getEm()` and `withTransaction()` were removed in feature 072 (T144).**
+ * They were the only `RequestContext` reference in the tree, and they had no
+ * callers outside this file — the header still advertised `withTransaction` as
+ * used by "order-placement, credit-limit reservation, and every multi-row
+ * mutation", none of which had called it for a long time.
+ *
+ * They are not worth restoring. `RequestContext` is AsyncLocalStorage-backed
+ * ambient state: a service reached the request's EntityManager by asking the
+ * runtime rather than by being given one, so what a service could touch was
+ * invisible in its signature and untestable without a live request scope. Every
+ * module takes an explicit `emFactory` now, and the kernel's request scope
+ * (`../kernel/scope.ts`) is where per-request state lives — declared, not
+ * ambient. Deleting these is what makes that a property of the tree rather than
+ * a convention.
+ *
+ * ## Why it is a factory (`specs/110-instance-repository/` T116)
+ *
+ * The cached instance is one process's, and so is the configuration it was
+ * booted from: which database this process talks to is decided by the host's
+ * `DATABASE_URL`, and which registries it was configured over is decided by the
+ * host's committed artefacts (R7.4). So the platform owns the bootstrap and the
+ * host owns the one call that binds it — `backend/src/db/index.ts` creates it
+ * once, at module scope, and re-exports the three names every caller already
+ * uses. One creation, one cached instance; two would be two ORMs over one pool.
+ */
+export interface OrmBootstrap {
+    initOrm(): Promise<MikroORM>;
+    getOrm(): MikroORM;
+    closeOrm(): Promise<void>;
+}
+export declare function createOrmBootstrap(config: () => Promise<Options>): OrmBootstrap;
+//# sourceMappingURL=orm.d.ts.map

package/dist/db/orm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.d.ts","sourceRoot":"","sources":["../../src/db/orm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7B,MAAM,IAAI,QAAQ,CAAC;IACnB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,YAAY,CAuB/E"}

package/dist/db/orm.js

@@ -0,0 +1,25 @@
+import { MikroORM } from '@mikro-orm/postgresql';
+export function createOrmBootstrap(config) {
+    let ormInstance;
+    return {
+        async initOrm() {
+            if (!ormInstance) {
+                ormInstance = await MikroORM.init(await config());
+            }
+            return ormInstance;
+        },
+        getOrm() {
+            if (!ormInstance) {
+                throw new Error('ORM not initialised — call initOrm() during application bootstrap.');
+            }
+            return ormInstance;
+        },
+        async closeOrm() {
+            if (ormInstance) {
+                await ormInstance.close(true);
+                ormInstance = undefined;
+            }
+        },
+    };
+}
+//# sourceMappingURL=orm.js.map

package/dist/db/orm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.js","sourceRoot":"","sources":["../../src/db/orm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAwCjD,MAAM,UAAU,kBAAkB,CAAC,MAA8B;IAC/D,IAAI,WAAiC,CAAC;IAEtC,OAAO;QACL,KAAK,CAAC,OAAO;YACX,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,WAAW,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,MAAM,MAAM,EAAE,CAAC,CAAC;YACpD,CAAC;YACD,OAAO,WAAW,CAAC;QACrB,CAAC;QACD,MAAM;YACJ,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;YACxF,CAAC;YACD,OAAO,WAAW,CAAC;QACrB,CAAC;QACD,KAAK,CAAC,QAAQ;YACZ,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC9B,WAAW,GAAG,SAAS,CAAC;YAC1B,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/db/platform-schema.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The platform's **own** schema — its six entity classes and its thirteen
+ * migrations — as a value the platform contributes to every composition
+ * (`specs/110-instance-repository/` T141).
+ *
+ * **Every count below is a derived fact written down, so re-derive before you
+ * edit one** (D-100). `PLATFORM_ENTITIES.length` and
+ * `PLATFORM_MIGRATION_ENTRIES.length` are the two answers, and their sum is what
+ * the generated registries name. `platform-schema.test.ts` derives rather than
+ * counts, so it does **not** catch this prose going stale — the bare `ls` of
+ * `../migrations/` does not either, since that directory also holds `index.ts`
+ * and `baseline-migrations.generated.ts`, which are not migrations.
+ *
+ * ## The defect this closes
+ *
+ * `configuredEntitiesFrom` and `discoverConfiguredMigrations` take the
+ * committed core registry from the host (R7.4), and an instance has none: it
+ * ships no generated index and no committed registry, so it passes
+ * `coreEntities: []` and `coreEntries: []`. Measured on the first end-to-end run
+ * of `endora new instance` (T140), that is not "an instance runs its packages'
+ * schema and no more" — it is an instance that runs **none of the platform's
+ * own**, because `AuditLogEntry`, `ModuleRegistration`, `SalesChannel`,
+ * `SettingGroup`, `SettingValue` and `Setting` live in this package and reach a
+ * composition only by being named. The first migration to touch a table
+ * `core_foundation_init` creates dies with `relation … does not exist`, and
+ * there is nothing a client could write in their own tree to prevent it.
+ *
+ * ## Why the platform carries it, and why that is not a new principle
+ *
+ * `../migrations/index.ts` already makes this argument for `BASELINE_MIGRATIONS`
+ * and R1.5 rules it: *"it is data about **this platform's** history, a client
+ * receives it by installing the platform, and a client receives a correction to
+ * it by `pnpm update`"*. The order and the migrations it orders are the same
+ * datum one step apart. A client's tree listing our thirteen class names would
+ * be a fact about our history held in a repository we cannot grep — exactly what
+ * R1.5 refuses — and it went stale on the thirteenth, which has now landed.
+ *
+ * ## Why merging is safe where a host **does** supply them
+ *
+ * This repository's own `entities-registry.generated.ts` and
+ * `migrations-registry.generated.ts` name all nineteen, by the bare specifiers
+ * this package's `exports` map declares. So the host's array and this one hold
+ * **the same objects**, and the merge below is an identity de-duplication — not
+ * a heuristic, and not a name comparison that could coalesce two different
+ * classes. Two *different* objects of one name can only come from two copies of
+ * this package in one process, which is D-160.6's failure; it survives the merge
+ * as a duplicate name, which `orderMigrations` refuses by its own rule.
+ *
+ * Nothing is removed from the generated registries in the same breath: they are
+ * the host's artefacts, emitted by a tree walk this file cannot reach, and a
+ * merge that is exact needs no second edit to be correct.
+ */
+import type { EntityClassLike } from '../packages/package-runtime.js';
+import type { MigrationRegistryEntry } from './migration-order.js';
+/**
+ * The cross-cutting pseudo-module owning the platform's own migrations.
+ *
+ * Declared here, beside the migrations it owns, and re-exported from
+ * `./configured-migrations.ts` where it used to live: that file now reads this
+ * one, so a constant declared there and read back would be an import cycle
+ * evaluated in whichever order a consumer happened to enter it. Five programs
+ * need the same literal and a second spelling of a module id is a second answer
+ * waiting to disagree.
+ */
+export declare const CORE_MODULE_ID = "core";
+/**
+ * The entity classes this package persists.
+ *
+ * Named one per line rather than re-exported from the two barrels that publish
+ * them: `./kernel` carries five and `./composition` carries
+ * `ModuleRegistration`, and a barrel import here would pull the composition
+ * root into every process that only wanted an ORM configuration.
+ */
+export declare const PLATFORM_ENTITIES: readonly EntityClassLike[];
+/**
+ * The platform's thirteen migrations, owned by the cross-cutting `core`
+ * pseudo-module.
+ *
+ * `origin` is left absent, which {@link MigrationRegistryEntry} documents as
+ * meaning `'core'` — these are not an external producer's, and writing the
+ * default would be a second spelling of it.
+ */
+export declare const PLATFORM_MIGRATION_ENTRIES: readonly MigrationRegistryEntry[];
+/**
+ * `first`, then every member of `second` whose **identity** is not already in
+ * it.
+ *
+ * `identity` is what a member is compared on, and it is a parameter because the
+ * two merges compare different things. An entity set holds the classes
+ * themselves, so a member is its own identity. A migration registry holds
+ * `{ moduleId, cls }` *wrappers*, and the host builds its own — so comparing
+ * the wrappers finds no overlap at all and hands `orderMigrations` twelve
+ * duplicate names. The class is the identity there, which is also what the
+ * platform persists: `cls.name` is the string `mikro_orm_migrations` records.
+ *
+ * Order is `first`'s and then `second`'s, so a host that already names these
+ * keeps its own positions and an instance receives them in the order declared
+ * above. For migrations neither order is the execution order: `orderMigrations`
+ * computes that from the baseline and the manifest graph.
+ */
+export declare function mergeByIdentity<T>(first: readonly T[], second: readonly T[], identity?: (member: T) => unknown): T[];
+//# sourceMappingURL=platform-schema.d.ts.map

package/dist/db/platform-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-schema.d.ts","sourceRoot":"","sources":["../../src/db/platform-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAsBtE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,SAAS,CAAC;AAErC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,eAAe,EAOvD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,sBAAsB,EAcrB,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,QAAQ,GAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAA4B,GACpD,CAAC,EAAE,CAGL"}

package/dist/db/platform-schema.js

@@ -0,0 +1,79 @@
+import { AuditLogEntry } from '../kernel/audit/audit-log-entry.entity.js';
+import { ModuleRegistration } from '../kernel/lifecycle/module-registration.entity.js';
+import { SalesChannel } from '../kernel/sales-channels/sales-channel.entity.js';
+import { Setting } from '../kernel/settings/setting.entity.js';
+import { SettingGroup } from '../kernel/settings/setting-group.entity.js';
+import { SettingValue } from '../kernel/settings/setting-value.entity.js';
+import { Migration20260424T165847CoreFoundationInit, Migration20260425T050720CoreCommerceInit, Migration20260430T101450CoreSettingsInit, Migration20260430T170044CoreSalesChannelsPromote, Migration20260506T200657CoreModuleLifecycleInit, Migration20260514T111329CoreSettingsGlobalValue, Migration20260611T140411CoreSettingsSecretValueType, Migration20260611T140419CoreSettingsEnumOptions, Migration20260629T090100CoreSettingsHiddenFlag, Migration20260717T134752CoreTenantScopeIndexes, Migration20260721T011510CoreSettingsCredentialRefValueType, Migration20260816T203339CoreRetireCoreActivationSettings, Migration20260919T101500CoreModuleRegistrationsBootConverged, } from '../migrations/index.js';
+/**
+ * The cross-cutting pseudo-module owning the platform's own migrations.
+ *
+ * Declared here, beside the migrations it owns, and re-exported from
+ * `./configured-migrations.ts` where it used to live: that file now reads this
+ * one, so a constant declared there and read back would be an import cycle
+ * evaluated in whichever order a consumer happened to enter it. Five programs
+ * need the same literal and a second spelling of a module id is a second answer
+ * waiting to disagree.
+ */
+export const CORE_MODULE_ID = 'core';
+/**
+ * The entity classes this package persists.
+ *
+ * Named one per line rather than re-exported from the two barrels that publish
+ * them: `./kernel` carries five and `./composition` carries
+ * `ModuleRegistration`, and a barrel import here would pull the composition
+ * root into every process that only wanted an ORM configuration.
+ */
+export const PLATFORM_ENTITIES = [
+    AuditLogEntry,
+    ModuleRegistration,
+    SalesChannel,
+    Setting,
+    SettingGroup,
+    SettingValue,
+];
+/**
+ * The platform's thirteen migrations, owned by the cross-cutting `core`
+ * pseudo-module.
+ *
+ * `origin` is left absent, which {@link MigrationRegistryEntry} documents as
+ * meaning `'core'` — these are not an external producer's, and writing the
+ * default would be a second spelling of it.
+ */
+export const PLATFORM_MIGRATION_ENTRIES = [
+    Migration20260424T165847CoreFoundationInit,
+    Migration20260425T050720CoreCommerceInit,
+    Migration20260430T101450CoreSettingsInit,
+    Migration20260430T170044CoreSalesChannelsPromote,
+    Migration20260506T200657CoreModuleLifecycleInit,
+    Migration20260514T111329CoreSettingsGlobalValue,
+    Migration20260611T140411CoreSettingsSecretValueType,
+    Migration20260611T140419CoreSettingsEnumOptions,
+    Migration20260629T090100CoreSettingsHiddenFlag,
+    Migration20260717T134752CoreTenantScopeIndexes,
+    Migration20260721T011510CoreSettingsCredentialRefValueType,
+    Migration20260816T203339CoreRetireCoreActivationSettings,
+    Migration20260919T101500CoreModuleRegistrationsBootConverged,
+].map((cls) => ({ moduleId: CORE_MODULE_ID, cls }));
+/**
+ * `first`, then every member of `second` whose **identity** is not already in
+ * it.
+ *
+ * `identity` is what a member is compared on, and it is a parameter because the
+ * two merges compare different things. An entity set holds the classes
+ * themselves, so a member is its own identity. A migration registry holds
+ * `{ moduleId, cls }` *wrappers*, and the host builds its own — so comparing
+ * the wrappers finds no overlap at all and hands `orderMigrations` twelve
+ * duplicate names. The class is the identity there, which is also what the
+ * platform persists: `cls.name` is the string `mikro_orm_migrations` records.
+ *
+ * Order is `first`'s and then `second`'s, so a host that already names these
+ * keeps its own positions and an instance receives them in the order declared
+ * above. For migrations neither order is the execution order: `orderMigrations`
+ * computes that from the baseline and the manifest graph.
+ */
+export function mergeByIdentity(first, second, identity = (member) => member) {
+    const seen = new Set(first.map(identity));
+    return [...first, ...second.filter((member) => !seen.has(identity(member)))];
+}
+//# sourceMappingURL=platform-schema.js.map

package/dist/db/platform-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-schema.js","sourceRoot":"","sources":["../../src/db/platform-schema.ts"],"names":[],"mappings":"AAqDA,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAAE,YAAY,EAAE,MAAM,kDAAkD,CAAC;AAChF,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EACL,0CAA0C,EAC1C,wCAAwC,EACxC,wCAAwC,EACxC,gDAAgD,EAChD,+CAA+C,EAC/C,+CAA+C,EAC/C,mDAAmD,EACnD,+CAA+C,EAC/C,8CAA8C,EAC9C,8CAA8C,EAC9C,0DAA0D,EAC1D,wDAAwD,EACxD,4DAA4D,GAC7D,MAAM,wBAAwB,CAAC;AAGhC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA+B;IAC3D,aAAa;IACb,kBAAkB;IAClB,YAAY;IACZ,OAAO;IACP,YAAY;IACZ,YAAY;CACb,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAsC;IAC3E,0CAA0C;IAC1C,wCAAwC;IACxC,wCAAwC;IACxC,gDAAgD;IAChD,+CAA+C;IAC/C,+CAA+C;IAC/C,mDAAmD;IACnD,+CAA+C;IAC/C,8CAA8C;IAC9C,8CAA8C;IAC9C,0DAA0D;IAC1D,wDAAwD;IACxD,4DAA4D;CAC7D,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAmB,EACnB,MAAoB,EACpB,WAAmC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM;IAErD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC1C,OAAO,CAAC,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC"}

package/dist/db/pluralizing-naming-strategy.d.ts

@@ -0,0 +1,16 @@
+import { UnderscoreNamingStrategy } from '@mikro-orm/core';
+export declare class PluralizingNamingStrategy extends UnderscoreNamingStrategy {
+    classToTableName(entityName: string): string;
+    referenceColumnName(): string;
+    joinKeyColumnName(entityName: string, _referencedColumnName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+}
+/** PascalCase / camelCase → snake_case. */
+export declare function toSnakeCase(input: string): string;
+/**
+ * Minimal English pluralizer. Covers the patterns we actually produce
+ * (names ending in s/x/z/ch/sh/y/consonant-y). Good enough for the entity inventory in
+ * data-model.md; a full inflector is YAGNI.
+ */
+export declare function pluralize(snake: string): string;
+//# sourceMappingURL=pluralizing-naming-strategy.d.ts.map

package/dist/db/pluralizing-naming-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluralizing-naming-strategy.d.ts","sourceRoot":"","sources":["../../src/db/pluralizing-naming-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAmB3D,qBAAa,yBAA0B,SAAQ,wBAAwB;IAC5D,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAQ5C,mBAAmB,IAAI,MAAM;IAK7B,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM;IAM7E,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;CAOjG;AAED,2CAA2C;AAC3C,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ/C"}

package/dist/db/pluralizing-naming-strategy.js

@@ -0,0 +1,66 @@
+import { UnderscoreNamingStrategy } from '@mikro-orm/core';
+/**
+ * MikroORM naming strategy enforcing Principle VI of the constitution:
+ *
+ * - Table names: plural `snake_case` (e.g. `Product` → `products`, `ComponentRoleTime` →
+ *   `component_role_times`).
+ * - Columns: `snake_case` (inherited from UnderscoreNamingStrategy).
+ * - Foreign keys: `{referenced_table_singular}_id` (e.g. `offer_id`, `user_id`).
+ * - Join tables: `{a}_{b}` in plural form.
+ *
+ * Permitted singular-class exceptions: `Auth`, `Example`. Any class name matching these
+ * exact PascalCase forms maps to the same lowercase snake_case without pluralization.
+ *
+ * See specs/001-b2b-platform-foundation/research.md R-04.
+ */
+const SINGULAR_EXCEPTIONS = new Set(['auth', 'example']);
+export class PluralizingNamingStrategy extends UnderscoreNamingStrategy {
+    classToTableName(entityName) {
+        const snake = toSnakeCase(entityName);
+        if (SINGULAR_EXCEPTIONS.has(snake)) {
+            return snake;
+        }
+        return pluralize(snake);
+    }
+    referenceColumnName() {
+        // FK column base: keep plain `id`. The prefix is added by joinKeyColumnName below.
+        return 'id';
+    }
+    joinKeyColumnName(entityName, _referencedColumnName) {
+        // Always produce `{referenced_table_singular}_id`, even if the class name is already singular.
+        const singular = toSnakeCase(entityName);
+        return `${singular}_id`;
+    }
+    joinTableName(sourceEntity, targetEntity, propertyName) {
+        // Default behaviour, but with plural snake_case on both sides.
+        const a = this.classToTableName(sourceEntity);
+        const b = this.classToTableName(targetEntity);
+        const prop = toSnakeCase(propertyName);
+        return `${a}_${b}_${prop}`;
+    }
+}
+/** PascalCase / camelCase → snake_case. */
+export function toSnakeCase(input) {
+    return input
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .toLowerCase();
+}
+/**
+ * Minimal English pluralizer. Covers the patterns we actually produce
+ * (names ending in s/x/z/ch/sh/y/consonant-y). Good enough for the entity inventory in
+ * data-model.md; a full inflector is YAGNI.
+ */
+export function pluralize(snake) {
+    if (snake.endsWith('s') || snake.endsWith('ch') || snake.endsWith('sh') || snake.endsWith('x') || snake.endsWith('z')) {
+        return `${snake}es`;
+    }
+    if (snake.endsWith('y') && snake.length > 1 && !isVowel(snake[snake.length - 2] ?? '')) {
+        return `${snake.slice(0, -1)}ies`;
+    }
+    return `${snake}s`;
+}
+function isVowel(ch) {
+    return ['a', 'e', 'i', 'o', 'u'].includes(ch);
+}
+//# sourceMappingURL=pluralizing-naming-strategy.js.map

package/dist/db/pluralizing-naming-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluralizing-naming-strategy.js","sourceRoot":"","sources":["../../src/db/pluralizing-naming-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AAEH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAEzD,MAAM,OAAO,yBAA0B,SAAQ,wBAAwB;IAC5D,gBAAgB,CAAC,UAAkB;QAC1C,MAAM,KAAK,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC;QACtC,IAAI,mBAAmB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAEQ,mBAAmB;QAC1B,mFAAmF;QACnF,OAAO,IAAI,CAAC;IACd,CAAC;IAEQ,iBAAiB,CAAC,UAAkB,EAAE,qBAA8B;QAC3E,+FAA+F;QAC/F,MAAM,QAAQ,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC;QACzC,OAAO,GAAG,QAAQ,KAAK,CAAC;IAC1B,CAAC;IAEQ,aAAa,CAAC,YAAoB,EAAE,YAAoB,EAAE,YAAoB;QACrF,+DAA+D;QAC/D,MAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAC9C,MAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAC9C,MAAM,IAAI,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC;QACvC,OAAO,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;IAC7B,CAAC;CACF;AAED,2CAA2C;AAC3C,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,OAAO,KAAK;SACT,OAAO,CAAC,uBAAuB,EAAE,OAAO,CAAC;SACzC,OAAO,CAAC,oBAAoB,EAAE,OAAO,CAAC;SACtC,WAAW,EAAE,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACtH,OAAO,GAAG,KAAK,IAAI,CAAC;IACtB,CAAC;IACD,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QACvF,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACpC,CAAC;IACD,OAAO,GAAG,KAAK,GAAG,CAAC;AACrB,CAAC;AAED,SAAS,OAAO,CAAC,EAAU;IACzB,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAChD,CAAC"}

package/dist/demo/guard.d.ts

@@ -0,0 +1,101 @@
+/**
+ * The two guards standing between a demo seed and somebody's live data.
+ *
+ * ## Why they are the platform's (feature 113, spec §7)
+ *
+ * `mustBeNonProduction()` is the safety property that makes every one of these
+ * commands runnable at all, and under **D-207** a client's backend takes
+ * `@endora-commerce/platform` and never receives the host's `backend/src`. A
+ * client running a demo seed against production is precisely what this file
+ * prevents, so it has to ship. It moved here from
+ * `backend/src/seeds/dev-seed-guard.ts`, which is now a re-export shim; the two
+ * consumers standing when it moved are `seed:dev` and
+ * `backend/scripts/conformance/seed-storefront-fixtures.ts`, and §3.3 requires
+ * the demo runner's entry point to call **this** implementation rather than a
+ * second copy.
+ *
+ * The body below is unchanged but for the operation its two refusals name:
+ * `dev-catalog-seed` became *"the demo seed"*, because from Phase 0 the same
+ * guard answers `endora demo seed` and an operator refused by it must not be
+ * sent to a host file they have never heard of and, under D-207, do not have.
+ * The sentence is true of `seed:dev` as well, which still runs throughout Phase
+ * 0 (FR-013 — the replacement exists before the removal).
+ *
+ * They live apart from the seed body, not inside it, because
+ * `dev-catalog-seed.ts` calls `main()` at import time: a test importing that
+ * file would run the seed it is supposed to be testing.
+ * `backend/test/unit/seeds/dev-seed-guard.test.ts` covers this module; the seed
+ * had no test at all, which is part of how issue #224 stood.
+ *
+ * ## Issue #224 — the second guard had never refused anything
+ *
+ * The database check used to be a regex over the whole DSN:
+ *
+ *     /localhost|127\.0\.0\.1|postgres(?::\d+)?/.test(url)
+ *
+ * The `postgres` alternative was meant to match the docker-compose service
+ * hostname. Tested against the whole DSN it matches the **scheme** instead —
+ * every PostgreSQL DSN begins `postgresql://` — so it accepted
+ * `postgresql://user:pw@db.production.example.com:5432/shop` and every other
+ * remote database, on every host, for as long as it existed. `NODE_ENV` was
+ * the only guard actually guarding; the second one was decoration.
+ *
+ * So: parse the DSN and test the **host**, and where the host cannot answer,
+ * test the database **name**.
+ */
+/**
+ * A database name that says "this database exists to be wiped".
+ *
+ * Deliberately the *same* judgement `test/global-setup.ts` makes before it
+ * lets the vitest harness truncate a database — a second, parallel convention
+ * would be one more thing to keep true. The unit test pins the two together by
+ * reading that file, so the day the harness changes its mind this stops
+ * compiling agreement rather than drifting quietly.
+ */
+export declare const TEST_DATABASE_NAME_PATTERN: RegExp;
+export interface SeedTargetVerdict {
+    readonly safe: boolean;
+    /** Host and database only — a DSN carries a password and this reaches logs. */
+    readonly describe: string;
+    readonly why: string;
+}
+/**
+ * Is `url` a database the seed may truncate?
+ *
+ * Three answers, in order:
+ *
+ *   1. **Unparseable** — refuse. `new URL()` throws where the old regex merely
+ *      failed to match, and an unhandled `TypeError: Invalid URL` from a
+ *      data-wipe guard reads like a crash rather than a refusal. Caught, and
+ *      re-thrown by the caller as the guard's own sentence.
+ *   2. **Loopback host** — allow, whatever the database is called. This is the
+ *      dev path: `backend/.env` ships
+ *      `postgresql://b2b:b2b@localhost:5432/b2b` and `pnpm run dev` runs on
+ *      the host against the published compose port.
+ *   3. **Anything else** — allow only if the database *name* follows the test
+ *      convention. `postgres` is the compose service name in `docker-compose.yml`
+ *      *and* in `deploy/compose.prod.yml`, so the host genuinely cannot tell a
+ *      dev stack from a production one; the CI DSN
+ *      (`postgresql://b2b:b2b@postgres:5432/b2b_test`) is separated from the
+ *      production DSN (`…@postgres:5432/b2b`) by the database name and by
+ *      nothing else.
+ *
+ * This is the most restrictive rule that leaves `pnpm run dev` working. The
+ * looser arm considered and rejected: keeping the host `postgres` sufficient
+ * on its own, which is what the old regex was reaching for. That admits
+ * `deploy/compose.prod.yml`'s own `DATABASE_URL` verbatim — the exact DSN a
+ * `seed` service in the production stack would have been handed.
+ */
+export declare function classifySeedTarget(url: string): SeedTargetVerdict;
+/**
+ * Refuse to seed anything but a development or test database.
+ *
+ * Two independent questions — "is this a production runtime?" and "is this a
+ * disposable database?" — with an explicit opt-out each. Neither answers for
+ * the other (issue #224).
+ *
+ * `env` is a parameter so the unit test can hand over a whole environment
+ * rather than mutating the process's.
+ */
+export declare function mustBeNonProduction(env?: NodeJS.ProcessEnv): void;
+//# sourceMappingURL=guard.d.ts.map

package/dist/demo/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/demo/guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAiBH;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,QAAmB,CAAC;AAwB3D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAyBjE;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,IAAI,CAsB9E"}

package/dist/demo/guard.js

@@ -0,0 +1,168 @@
+/**
+ * The two guards standing between a demo seed and somebody's live data.
+ *
+ * ## Why they are the platform's (feature 113, spec §7)
+ *
+ * `mustBeNonProduction()` is the safety property that makes every one of these
+ * commands runnable at all, and under **D-207** a client's backend takes
+ * `@endora-commerce/platform` and never receives the host's `backend/src`. A
+ * client running a demo seed against production is precisely what this file
+ * prevents, so it has to ship. It moved here from
+ * `backend/src/seeds/dev-seed-guard.ts`, which is now a re-export shim; the two
+ * consumers standing when it moved are `seed:dev` and
+ * `backend/scripts/conformance/seed-storefront-fixtures.ts`, and §3.3 requires
+ * the demo runner's entry point to call **this** implementation rather than a
+ * second copy.
+ *
+ * The body below is unchanged but for the operation its two refusals name:
+ * `dev-catalog-seed` became *"the demo seed"*, because from Phase 0 the same
+ * guard answers `endora demo seed` and an operator refused by it must not be
+ * sent to a host file they have never heard of and, under D-207, do not have.
+ * The sentence is true of `seed:dev` as well, which still runs throughout Phase
+ * 0 (FR-013 — the replacement exists before the removal).
+ *
+ * They live apart from the seed body, not inside it, because
+ * `dev-catalog-seed.ts` calls `main()` at import time: a test importing that
+ * file would run the seed it is supposed to be testing.
+ * `backend/test/unit/seeds/dev-seed-guard.test.ts` covers this module; the seed
+ * had no test at all, which is part of how issue #224 stood.
+ *
+ * ## Issue #224 — the second guard had never refused anything
+ *
+ * The database check used to be a regex over the whole DSN:
+ *
+ *     /localhost|127\.0\.0\.1|postgres(?::\d+)?/.test(url)
+ *
+ * The `postgres` alternative was meant to match the docker-compose service
+ * hostname. Tested against the whole DSN it matches the **scheme** instead —
+ * every PostgreSQL DSN begins `postgresql://` — so it accepted
+ * `postgresql://user:pw@db.production.example.com:5432/shop` and every other
+ * remote database, on every host, for as long as it existed. `NODE_ENV` was
+ * the only guard actually guarding; the second one was decoration.
+ *
+ * So: parse the DSN and test the **host**, and where the host cannot answer,
+ * test the database **name**.
+ */
+/**
+ * Hosts that can only mean "the machine running the seed".
+ *
+ * A loopback DSN cannot reach another machine's database, so the operator is
+ * seeding something in front of them. Seeding a production box's own database
+ * over loopback is the case `NODE_ENV=production` answers — that guard, and
+ * not this one.
+ *
+ * `::1` arrives from `new URL()` as `[::1]`; `hostOf` strips the brackets.
+ * Only these three exact spellings: `127.0.0.2` and friends are loopback too,
+ * but nothing in this repository uses one, and the whole defect above came
+ * from a host test that was broader than it looked.
+ */
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '::1']);
+/**
+ * A database name that says "this database exists to be wiped".
+ *
+ * Deliberately the *same* judgement `test/global-setup.ts` makes before it
+ * lets the vitest harness truncate a database — a second, parallel convention
+ * would be one more thing to keep true. The unit test pins the two together by
+ * reading that file, so the day the harness changes its mind this stops
+ * compiling agreement rather than drifting quietly.
+ */
+export const TEST_DATABASE_NAME_PATTERN = /(^|_)test(_|$)/;
+/**
+ * Set to `true` to run the seed against a database that is neither loopback
+ * nor named as a test database — a demo deployment being the case that has a
+ * claim on it.
+ *
+ * It is a *separate* flag from `ALLOW_DEV_SEED_IN_PRODUCTION` on purpose. The
+ * lesson of issue #224 is that one guard silently covering for the other is
+ * how a wipe reaches live data: a deliberate demo seed must now say both "yes,
+ * production" and "yes, that database", and each answer is visible on its own
+ * in whatever ran the command.
+ */
+const NON_LOCAL_OVERRIDE = 'ALLOW_DEV_SEED_ON_NON_LOCAL_DATABASE';
+/** Lower-cased host with IPv6 brackets removed, or `''` for a unix-socket DSN. */
+function hostOf(parsed) {
+    return parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+}
+function databaseNameOf(parsed) {
+    return decodeURIComponent(parsed.pathname).replace(/^\//, '');
+}
+/**
+ * Is `url` a database the seed may truncate?
+ *
+ * Three answers, in order:
+ *
+ *   1. **Unparseable** — refuse. `new URL()` throws where the old regex merely
+ *      failed to match, and an unhandled `TypeError: Invalid URL` from a
+ *      data-wipe guard reads like a crash rather than a refusal. Caught, and
+ *      re-thrown by the caller as the guard's own sentence.
+ *   2. **Loopback host** — allow, whatever the database is called. This is the
+ *      dev path: `backend/.env` ships
+ *      `postgresql://b2b:b2b@localhost:5432/b2b` and `pnpm run dev` runs on
+ *      the host against the published compose port.
+ *   3. **Anything else** — allow only if the database *name* follows the test
+ *      convention. `postgres` is the compose service name in `docker-compose.yml`
+ *      *and* in `deploy/compose.prod.yml`, so the host genuinely cannot tell a
+ *      dev stack from a production one; the CI DSN
+ *      (`postgresql://b2b:b2b@postgres:5432/b2b_test`) is separated from the
+ *      production DSN (`…@postgres:5432/b2b`) by the database name and by
+ *      nothing else.
+ *
+ * This is the most restrictive rule that leaves `pnpm run dev` working. The
+ * looser arm considered and rejected: keeping the host `postgres` sufficient
+ * on its own, which is what the old regex was reaching for. That admits
+ * `deploy/compose.prod.yml`'s own `DATABASE_URL` verbatim — the exact DSN a
+ * `seed` service in the production stack would have been handed.
+ */
+export function classifySeedTarget(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return { safe: false, describe: '<unparseable DATABASE_URL>', why: 'it is not a URL' };
+    }
+    const host = hostOf(parsed);
+    const database = databaseNameOf(parsed);
+    const describe = `host "${host || '<none>'}", database "${database}"`;
+    if (LOOPBACK_HOSTS.has(host)) {
+        return { safe: true, describe, why: 'the host is loopback' };
+    }
+    if (TEST_DATABASE_NAME_PATTERN.test(database)) {
+        return { safe: true, describe, why: 'the database name follows the test convention' };
+    }
+    return {
+        safe: false,
+        describe,
+        why: 'the host is not loopback and the database name does not contain "test" ' +
+            '(the convention test/global-setup.ts uses before it truncates)',
+    };
+}
+/**
+ * Refuse to seed anything but a development or test database.
+ *
+ * Two independent questions — "is this a production runtime?" and "is this a
+ * disposable database?" — with an explicit opt-out each. Neither answers for
+ * the other (issue #224).
+ *
+ * `env` is a parameter so the unit test can hand over a whole environment
+ * rather than mutating the process's.
+ */
+export function mustBeNonProduction(env = process.env) {
+    // The seed is destructive (it truncates the public catalog/business tables),
+    // so it refuses NODE_ENV=production by default. A deliberate demo deployment
+    // can opt in with ALLOW_DEV_SEED_IN_PRODUCTION=true — this is intentionally a
+    // separate, explicit flag so an accidental run never wipes real data.
+    const forced = env['ALLOW_DEV_SEED_IN_PRODUCTION'] === 'true';
+    if (env['NODE_ENV'] === 'production' && !forced) {
+        throw new Error('refusing to run the demo seed in NODE_ENV=production ' +
+            '(set ALLOW_DEV_SEED_IN_PRODUCTION=true to override — this WIPES business data)');
+    }
+    const url = env['DATABASE_URL'] ?? 'postgresql://b2b:b2b@localhost:5432/b2b';
+    const verdict = classifySeedTarget(url);
+    if (!verdict.safe && env[NON_LOCAL_OVERRIDE] !== 'true') {
+        throw new Error(`refusing to run the demo seed against ${verdict.describe}: ${verdict.why}. ` +
+            `This seed truncates the catalog and business tables. Set ${NON_LOCAL_OVERRIDE}=true ` +
+            'if that database really is disposable.');
+    }
+}
+//# sourceMappingURL=guard.js.map

package/dist/demo/guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.js","sourceRoot":"","sources":["../../src/demo/guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC;AAEvF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,gBAAgB,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,MAAM,kBAAkB,GAAG,sCAAsC,CAAC;AAElE,kFAAkF;AAClF,SAAS,MAAM,CAAC,MAAW;IACzB,OAAO,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,cAAc,CAAC,MAAW;IACjC,OAAO,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AAChE,CAAC;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC5C,IAAI,MAAW,CAAC;IAChB,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,4BAA4B,EAAE,GAAG,EAAE,iBAAiB,EAAE,CAAC;IACzF,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,SAAS,IAAI,IAAI,QAAQ,gBAAgB,QAAQ,GAAG,CAAC;IAEtE,IAAI,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,sBAAsB,EAAE,CAAC;IAC/D,CAAC;IACD,IAAI,0BAA0B,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,+CAA+C,EAAE,CAAC;IACxF,CAAC;IACD,OAAO;QACL,IAAI,EAAE,KAAK;QACX,QAAQ;QACR,GAAG,EACD,yEAAyE;YACzE,gEAAgE;KACnE,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAyB,OAAO,CAAC,GAAG;IACtE,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,sEAAsE;IACtE,MAAM,MAAM,GAAG,GAAG,CAAC,8BAA8B,CAAC,KAAK,MAAM,CAAC;IAC9D,IAAI,GAAG,CAAC,UAAU,CAAC,KAAK,YAAY,IAAI,CAAC,MAAM,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CACb,uDAAuD;YACrD,gFAAgF,CACnF,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,GAAG,CAAC,cAAc,CAAC,IAAI,yCAAyC,CAAC;IAC7E,MAAM,OAAO,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,GAAG,CAAC,kBAAkB,CAAC,KAAK,MAAM,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CACb,yCAAyC,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,GAAG,IAAI;YAC3E,4DAA4D,kBAAkB,QAAQ;YACtF,wCAAwC,CAC3C,CAAC;IACJ,CAAC;AACH,CAAC"}