@astram/engine 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Typed engine errors. All fail-closed: a stage that throws aborts the pipe and
+ * rolls back the transaction (no partial write, no silent degrade).
+ */
+/** Base for all engine-originated errors (lets consumers catch the whole family). */
+export declare class EngineError extends Error {
+    constructor(message: string);
+}
+/**
+ * The GAP-FLAG STOP (§design 2.8). Thrown when a feature asks the pipe for a
+ * capability it does not implement (an unsupported field type, an operation no
+ * stage handles). It is LOUD and typed — never a silent degrade. The AI guide
+ * (ADR-0025) instructs: on this error STOP, record the gap in `.astram/gaps.md`,
+ * and do NOT work around it (the wall makes a workaround impossible anyway). The
+ * framework fills the capability properly, then the feature resumes.
+ */
+export declare class CapabilityNotSupportedError extends EngineError {
+    /** The missing capability (stable, greppable — e.g. `fieldType:geo`). */
+    readonly capability: string;
+    constructor(
+    /** The missing capability (stable, greppable — e.g. `fieldType:geo`). */
+    capability: string, 
+    /** Human detail naming what was attempted. */
+    detail: string);
+}
+/** A registration/config error (a feature declared something invalid). */
+export declare class RegistrationError extends EngineError {
+}
+/** The permission gate denied the operation (fail-closed). Carries the reason code. */
+export declare class AuthorizationDeniedError extends EngineError {
+    readonly reason: string;
+    constructor(reason: string, detail?: string);
+}
+/** Input failed validation (types/required/unknown-field). */
+export declare class ValidationError extends EngineError {
+    readonly field: string;
+    constructor(field: string, detail: string);
+}
+/**
+ * A transient/unavailable failure (the decision authority or store signalled it
+ * cannot answer right now — ADR-0016). Distinct from a deny: callers may retry.
+ * Fail-closed: the operation still does not proceed.
+ */
+export declare class EngineUnavailableError extends EngineError {
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qFAAqF;AACrF,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;GAOG;AACH,qBAAa,2BAA4B,SAAQ,WAAW;IAExD,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,MAAM;;IAD3B,yEAAyE;IAChE,UAAU,EAAE,MAAM;IAC3B,8CAA8C;IAC9C,MAAM,EAAE,MAAM;CAQjB;AAED,0EAA0E;AAC1E,qBAAa,iBAAkB,SAAQ,WAAW;CAAG;AAErD,uFAAuF;AACvF,qBAAa,wBAAyB,SAAQ,WAAW;IAErD,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM,EACvB,MAAM,CAAC,EAAE,MAAM;CAIlB;AAED,8DAA8D;AAC9D,qBAAa,eAAgB,SAAQ,WAAW;IAE5C,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM;CAIjB;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,WAAW;CAAG"}

package/dist/errors.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Typed engine errors. All fail-closed: a stage that throws aborts the pipe and
+ * rolls back the transaction (no partial write, no silent degrade).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineUnavailableError = exports.ValidationError = exports.AuthorizationDeniedError = exports.RegistrationError = exports.CapabilityNotSupportedError = exports.EngineError = void 0;
+/** Base for all engine-originated errors (lets consumers catch the whole family). */
+class EngineError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+exports.EngineError = EngineError;
+/**
+ * The GAP-FLAG STOP (§design 2.8). Thrown when a feature asks the pipe for a
+ * capability it does not implement (an unsupported field type, an operation no
+ * stage handles). It is LOUD and typed — never a silent degrade. The AI guide
+ * (ADR-0025) instructs: on this error STOP, record the gap in `.astram/gaps.md`,
+ * and do NOT work around it (the wall makes a workaround impossible anyway). The
+ * framework fills the capability properly, then the feature resumes.
+ */
+class CapabilityNotSupportedError extends EngineError {
+    capability;
+    constructor(
+    /** The missing capability (stable, greppable — e.g. `fieldType:geo`). */
+    capability, 
+    /** Human detail naming what was attempted. */
+    detail) {
+        super(`CapabilityNotSupported [${capability}]: ${detail}. ` +
+            `STOP — this is a framework gap. Record it in .astram/gaps.md and do NOT ` +
+            `work around the pipe; the capability must be added to @astram/engine.`);
+        this.capability = capability;
+    }
+}
+exports.CapabilityNotSupportedError = CapabilityNotSupportedError;
+/** A registration/config error (a feature declared something invalid). */
+class RegistrationError extends EngineError {
+}
+exports.RegistrationError = RegistrationError;
+/** The permission gate denied the operation (fail-closed). Carries the reason code. */
+class AuthorizationDeniedError extends EngineError {
+    reason;
+    constructor(reason, detail) {
+        super(`Authorization denied [${reason}]${detail ? `: ${detail}` : ''}.`);
+        this.reason = reason;
+    }
+}
+exports.AuthorizationDeniedError = AuthorizationDeniedError;
+/** Input failed validation (types/required/unknown-field). */
+class ValidationError extends EngineError {
+    field;
+    constructor(field, detail) {
+        super(`Validation failed for '${field}': ${detail}.`);
+        this.field = field;
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * A transient/unavailable failure (the decision authority or store signalled it
+ * cannot answer right now — ADR-0016). Distinct from a deny: callers may retry.
+ * Fail-closed: the operation still does not proceed.
+ */
+class EngineUnavailableError extends EngineError {
+}
+exports.EngineUnavailableError = EngineUnavailableError;

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,qFAAqF;AACrF,MAAa,WAAY,SAAQ,KAAK;IACpC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;IAC9B,CAAC;CACF;AALD,kCAKC;AAED;;;;;;;GAOG;AACH,MAAa,2BAA4B,SAAQ,WAAW;IAG/C;IAFX;IACE,yEAAyE;IAChE,UAAkB;IAC3B,8CAA8C;IAC9C,MAAc;QAEd,KAAK,CACH,2BAA2B,UAAU,MAAM,MAAM,IAAI;YACnD,0EAA0E;YAC1E,uEAAuE,CAC1E,CAAC;QARO,eAAU,GAAV,UAAU,CAAQ;IAS7B,CAAC;CACF;AAbD,kEAaC;AAED,0EAA0E;AAC1E,MAAa,iBAAkB,SAAQ,WAAW;CAAG;AAArD,8CAAqD;AAErD,uFAAuF;AACvF,MAAa,wBAAyB,SAAQ,WAAW;IAE5C;IADX,YACW,MAAc,EACvB,MAAe;QAEf,KAAK,CAAC,yBAAyB,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAHhE,WAAM,GAAN,MAAM,CAAQ;IAIzB,CAAC;CACF;AAPD,4DAOC;AAED,8DAA8D;AAC9D,MAAa,eAAgB,SAAQ,WAAW;IAEnC;IADX,YACW,KAAa,EACtB,MAAc;QAEd,KAAK,CAAC,0BAA0B,KAAK,MAAM,MAAM,GAAG,CAAC,CAAC;QAH7C,UAAK,GAAL,KAAK,CAAQ;IAIxB,CAAC;CACF;AAPD,0CAOC;AAED;;;;GAIG;AACH,MAAa,sBAAuB,SAAQ,WAAW;CAAG;AAA1D,wDAA0D"}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @astram/engine — the paved road. Public surface.
+ *
+ * FEATURE-FACING (what a feature uses):
+ *  - `RECORD_ENGINE` token + `RecordEngine` interface — the ONE data-access facade.
+ *  - `ObjectType` / `FieldSpec` / `JunctionSpec` / `RecordInput` / … — the
+ *    metadata contract a feature declares.
+ *  - `EngineModule.forRoot(...)` — wiring (the wall: only the facade is exported to
+ *    feature scope; the pool/uow/audit stay sealed inside the module).
+ *  - The typed errors — especially `CapabilityNotSupportedError` (the gap-flag STOP).
+ *
+ * FRAMEWORK-FACING (composition/tests; a FEATURE must NOT import these — the app's
+ * architectural lint rule blocks raw DB access under src/features/**):
+ *  - the adapters (`MariaDbUnitOfWork`, `MariaDbAuditSink`), the `RecordEngineImpl`,
+ *    the `TableRegistry`, and the ports. Exported so the framework + integration
+ *    tests can compose the engine directly; NOT for feature code.
+ */
+export type { RecordEngine, AccessDeclaration, FieldSpec, FieldType, TrustedSource, IdentityRole, PkStrategy, JunctionSpec, RecordInput, RecordId, RecordView, ListQuery, RecordPage, Principal, } from './types.js';
+export { EngineError, CapabilityNotSupportedError, RegistrationError, AuthorizationDeniedError, ValidationError, EngineUnavailableError, } from './errors.js';
+export { ObjectType, Field, PrimaryKey, reflectObjectType, type ObjectTypeOptions, type FieldOptions, type PrimaryKeyOptions, } from './decorators/object-type.decorator.js';
+export { AccessBundle, reflectAccessBundle, type AccessBundleOptions, type AccessBundlePermission, type AccessBundleSpec, } from './decorators/access-bundle.decorator.js';
+export { EngineModule, RECORD_ENGINE, ENGINE_ALL_REGISTRATIONS, ENGINE_ALL_ACCESS_BUNDLES, type EngineModuleOptions, type ObjectTypeInput, } from './module/engine.module.js';
+export { TableRegistry, columnOf, uuidPkColumn, isOwned, ownerColumn, tenantColumnOf, columnForRole, requireRole, } from './registry.js';
+export { RecordEngineImpl, type RecordEngineDeps } from './pipe/record-engine.js';
+export { RecordsService, BoundRecords, type ServiceAccountResolver, SERVICE_ACCOUNT_RESOLVER, } from './pipe/records-service.js';
+export { MariaDbUnitOfWork, type EngineDbConfig, } from './adapters/mariadb-unit-of-work.js';
+export { MariaDbAuditSink, type AuditSinkConfig } from './adapters/mariadb-audit-sink.js';
+export type { QueryFn, UnitOfWork, DecisionPort, AuditPort, } from './ports.js';
+export type { Stage, WriteContext, WriteOp, PipeBase } from './pipe/context.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,SAAS,EACT,SAAS,EACT,aAAa,EACb,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,WAAW,EACX,QAAQ,EACR,UAAU,EACV,SAAS,EACT,UAAU,EACV,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,WAAW,EACX,2BAA2B,EAC3B,iBAAiB,EACjB,wBAAwB,EACxB,eAAe,EACf,sBAAsB,GACvB,MAAM,aAAa,CAAC;AAiBrB,OAAO,EACL,UAAU,EACV,KAAK,EACL,UAAU,EACV,iBAAiB,EACjB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,iBAAiB,GACvB,MAAM,uCAAuC,CAAC;AAO/C,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,GACtB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EACL,YAAY,EACZ,aAAa,EACb,wBAAwB,EACxB,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,eAAe,GACrB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EACL,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,WAAW,EACX,cAAc,EACd,aAAa,EACb,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,EACL,cAAc,EACd,YAAY,EACZ,KAAK,sBAAsB,EAC3B,wBAAwB,GACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,iBAAiB,EACjB,KAAK,cAAc,GACpB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC1F,YAAY,EACV,OAAO,EACP,UAAU,EACV,YAAY,EACZ,SAAS,GACV,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * @astram/engine — the paved road. Public surface.
+ *
+ * FEATURE-FACING (what a feature uses):
+ *  - `RECORD_ENGINE` token + `RecordEngine` interface — the ONE data-access facade.
+ *  - `ObjectType` / `FieldSpec` / `JunctionSpec` / `RecordInput` / … — the
+ *    metadata contract a feature declares.
+ *  - `EngineModule.forRoot(...)` — wiring (the wall: only the facade is exported to
+ *    feature scope; the pool/uow/audit stay sealed inside the module).
+ *  - The typed errors — especially `CapabilityNotSupportedError` (the gap-flag STOP).
+ *
+ * FRAMEWORK-FACING (composition/tests; a FEATURE must NOT import these — the app's
+ * architectural lint rule blocks raw DB access under src/features/**):
+ *  - the adapters (`MariaDbUnitOfWork`, `MariaDbAuditSink`), the `RecordEngineImpl`,
+ *    the `TableRegistry`, and the ports. Exported so the framework + integration
+ *    tests can compose the engine directly; NOT for feature code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MariaDbAuditSink = exports.MariaDbUnitOfWork = exports.SERVICE_ACCOUNT_RESOLVER = exports.BoundRecords = exports.RecordsService = exports.RecordEngineImpl = exports.requireRole = exports.columnForRole = exports.tenantColumnOf = exports.ownerColumn = exports.isOwned = exports.uuidPkColumn = exports.columnOf = exports.TableRegistry = exports.ENGINE_ALL_ACCESS_BUNDLES = exports.ENGINE_ALL_REGISTRATIONS = exports.RECORD_ENGINE = exports.EngineModule = exports.reflectAccessBundle = exports.AccessBundle = exports.reflectObjectType = exports.PrimaryKey = exports.Field = exports.ObjectType = exports.EngineUnavailableError = exports.ValidationError = exports.AuthorizationDeniedError = exports.RegistrationError = exports.CapabilityNotSupportedError = exports.EngineError = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "EngineError", { enumerable: true, get: function () { return errors_js_1.EngineError; } });
+Object.defineProperty(exports, "CapabilityNotSupportedError", { enumerable: true, get: function () { return errors_js_1.CapabilityNotSupportedError; } });
+Object.defineProperty(exports, "RegistrationError", { enumerable: true, get: function () { return errors_js_1.RegistrationError; } });
+Object.defineProperty(exports, "AuthorizationDeniedError", { enumerable: true, get: function () { return errors_js_1.AuthorizationDeniedError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_js_1.ValidationError; } });
+Object.defineProperty(exports, "EngineUnavailableError", { enumerable: true, get: function () { return errors_js_1.EngineUnavailableError; } });
+// The decorator layer: author an `ObjectType` as a metadata-only decorated class
+// (`@ObjectType` + `@PrimaryKey` + `@Field`). The decorated class IS the object type —
+// a feature passes the CLASS directly to `EngineModule.forFeature([...])` and never
+// reflects it itself.
+//
+// NOTE: `ObjectType` here is the SINGLE public source of that name — it is BOTH the
+// class DECORATOR (a value) AND the metadata contract TYPE, unified via DECLARATION
+// MERGING inside the decorator module (a `function ObjectType` + an `interface
+// ObjectType extends ObjectTypeContract` in the same module). So `@ObjectType(...)`
+// (value) and `: ObjectType` (type) both resolve from this one export — the data-shape
+// `ObjectType` is NO LONGER re-exported from ./types (that would be a duplicate name).
+//
+// `reflectObjectType` is FRAMEWORK/COMPOSE-FACING (the engine + tests use it to reflect
+// a class into its `ObjectType` literal); FEATURE code never calls it — `@ObjectType`
+// / `@Field` / `@PrimaryKey` on a class is the whole feature-facing author API.
+var object_type_decorator_js_1 = require("./decorators/object-type.decorator.js");
+Object.defineProperty(exports, "ObjectType", { enumerable: true, get: function () { return object_type_decorator_js_1.ObjectType; } });
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return object_type_decorator_js_1.Field; } });
+Object.defineProperty(exports, "PrimaryKey", { enumerable: true, get: function () { return object_type_decorator_js_1.PrimaryKey; } });
+Object.defineProperty(exports, "reflectObjectType", { enumerable: true, get: function () { return object_type_decorator_js_1.reflectObjectType; } });
+// The `@AccessBundle` decorator layer: a feature authors a NAMED, admin-grantable
+// permission bundle as a metadata-only decorated class, collected via
+// `EngineModule.forFeature([...], { accessBundles: [...] })` into
+// `ENGINE_ALL_ACCESS_BUNDLES`. `reflectAccessBundle` reads a class into its flat
+// `AccessBundleSpec` (the engine reflects registered classes internally).
+var access_bundle_decorator_js_1 = require("./decorators/access-bundle.decorator.js");
+Object.defineProperty(exports, "AccessBundle", { enumerable: true, get: function () { return access_bundle_decorator_js_1.AccessBundle; } });
+Object.defineProperty(exports, "reflectAccessBundle", { enumerable: true, get: function () { return access_bundle_decorator_js_1.reflectAccessBundle; } });
+var engine_module_js_1 = require("./module/engine.module.js");
+Object.defineProperty(exports, "EngineModule", { enumerable: true, get: function () { return engine_module_js_1.EngineModule; } });
+Object.defineProperty(exports, "RECORD_ENGINE", { enumerable: true, get: function () { return engine_module_js_1.RECORD_ENGINE; } });
+Object.defineProperty(exports, "ENGINE_ALL_REGISTRATIONS", { enumerable: true, get: function () { return engine_module_js_1.ENGINE_ALL_REGISTRATIONS; } });
+Object.defineProperty(exports, "ENGINE_ALL_ACCESS_BUNDLES", { enumerable: true, get: function () { return engine_module_js_1.ENGINE_ALL_ACCESS_BUNDLES; } });
+// --- Framework-facing (composition + tests; NOT for feature code) ------------
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "TableRegistry", { enumerable: true, get: function () { return registry_js_1.TableRegistry; } });
+Object.defineProperty(exports, "columnOf", { enumerable: true, get: function () { return registry_js_1.columnOf; } });
+Object.defineProperty(exports, "uuidPkColumn", { enumerable: true, get: function () { return registry_js_1.uuidPkColumn; } });
+Object.defineProperty(exports, "isOwned", { enumerable: true, get: function () { return registry_js_1.isOwned; } });
+Object.defineProperty(exports, "ownerColumn", { enumerable: true, get: function () { return registry_js_1.ownerColumn; } });
+Object.defineProperty(exports, "tenantColumnOf", { enumerable: true, get: function () { return registry_js_1.tenantColumnOf; } });
+Object.defineProperty(exports, "columnForRole", { enumerable: true, get: function () { return registry_js_1.columnForRole; } });
+Object.defineProperty(exports, "requireRole", { enumerable: true, get: function () { return registry_js_1.requireRole; } });
+var record_engine_js_1 = require("./pipe/record-engine.js");
+Object.defineProperty(exports, "RecordEngineImpl", { enumerable: true, get: function () { return record_engine_js_1.RecordEngineImpl; } });
+var records_service_js_1 = require("./pipe/records-service.js");
+Object.defineProperty(exports, "RecordsService", { enumerable: true, get: function () { return records_service_js_1.RecordsService; } });
+Object.defineProperty(exports, "BoundRecords", { enumerable: true, get: function () { return records_service_js_1.BoundRecords; } });
+Object.defineProperty(exports, "SERVICE_ACCOUNT_RESOLVER", { enumerable: true, get: function () { return records_service_js_1.SERVICE_ACCOUNT_RESOLVER; } });
+var mariadb_unit_of_work_js_1 = require("./adapters/mariadb-unit-of-work.js");
+Object.defineProperty(exports, "MariaDbUnitOfWork", { enumerable: true, get: function () { return mariadb_unit_of_work_js_1.MariaDbUnitOfWork; } });
+var mariadb_audit_sink_js_1 = require("./adapters/mariadb-audit-sink.js");
+Object.defineProperty(exports, "MariaDbAuditSink", { enumerable: true, get: function () { return mariadb_audit_sink_js_1.MariaDbAuditSink; } });

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAmBH,yCAOqB;AANnB,wGAAA,WAAW,OAAA;AACX,wHAAA,2BAA2B,OAAA;AAC3B,8GAAA,iBAAiB,OAAA;AACjB,qHAAA,wBAAwB,OAAA;AACxB,4GAAA,eAAe,OAAA;AACf,mHAAA,sBAAsB,OAAA;AAGxB,iFAAiF;AACjF,uFAAuF;AACvF,oFAAoF;AACpF,sBAAsB;AACtB,EAAE;AACF,oFAAoF;AACpF,oFAAoF;AACpF,+EAA+E;AAC/E,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,EAAE;AACF,wFAAwF;AACxF,sFAAsF;AACtF,gFAAgF;AAChF,kFAQ+C;AAP7C,sHAAA,UAAU,OAAA;AACV,iHAAA,KAAK,OAAA;AACL,sHAAA,UAAU,OAAA;AACV,6HAAA,iBAAiB,OAAA;AAMnB,kFAAkF;AAClF,sEAAsE;AACtE,kEAAkE;AAClE,iFAAiF;AACjF,0EAA0E;AAC1E,sFAMiD;AAL/C,0HAAA,YAAY,OAAA;AACZ,iIAAA,mBAAmB,OAAA;AAMrB,8DAOmC;AANjC,gHAAA,YAAY,OAAA;AACZ,iHAAA,aAAa,OAAA;AACb,4HAAA,wBAAwB,OAAA;AACxB,6HAAA,yBAAyB,OAAA;AAK3B,gFAAgF;AAChF,6CAOuB;AANrB,4GAAA,aAAa,OAAA;AACb,uGAAA,QAAQ,OAAA;AACR,2GAAA,YAAY,OAAA;AACZ,sGAAA,OAAO,OAAA;AACP,0GAAA,WAAW,OAAA;AACX,6GAAA,cAAc,OAAA;AAEhB,4DAAkF;AAAzE,oHAAA,gBAAgB,OAAA;AACzB,8EAG4C;AAF1C,4HAAA,iBAAiB,OAAA;AAGnB,0EAA0F;AAAjF,yHAAA,gBAAgB,OAAA"}

package/dist/module/engine.module.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `EngineModule` — the paved road's Nest wiring, and the PHYSICAL WALL.
+ *
+ * It provides EXACTLY ONE thing to feature scope: {@link RECORD_ENGINE} (the
+ * RecordEngine facade). The sealed collaborators — the mariadb pool / UnitOfWork,
+ * the audit sink, the table registry — are providers INTERNAL to this module and
+ * are NOT exported. A feature module that imports EngineModule can inject the engine
+ * facade and nothing else; it is never handed a pool, a query runner, or a
+ * repository. That absence is the wall (the lint rule in the consumer app is the
+ * backstop, not the primary mechanism).
+ *
+ * The permission-gate stage binds to the framework's single decision authority
+ * (guard's `SHIELD_DECISION_AUTHORITY`) — so the engine reuses the ONE decision path,
+ * never its own authz logic.
+ *
+ * OPT-IN + config: `EngineModule.forRoot({ db, registrations })`. The engine opens a
+ * live pool, so (like AuthModule) it is imported only by an app that uses the pipe.
+ * Registrations are code-registered tables loaded at boot.
+ */
+import { type DynamicModule } from '@nestjs/common';
+import type { QueryFn } from '../ports.js';
+import { RECORD_ENGINE } from './tokens.js';
+import { type EngineDbConfig } from '../adapters/mariadb-unit-of-work.js';
+import { type AuditSinkConfig } from '../adapters/mariadb-audit-sink.js';
+import type { ObjectType } from '../types.js';
+import { type AccessBundleSpec } from '../decorators/access-bundle.decorator.js';
+/**
+ * Input accepted by `forFeature` / `forRoot({registrations})`: either a plain
+ * {@link ObjectType} literal OR a class decorated with `@ObjectType` (`Function`).
+ * The engine normalizes every input to a reflected `ObjectType` internally, so the
+ * feature developer passes the DECORATED CLASS directly — no `reflectObjectType(...)`
+ * call in feature code.
+ */
+export type ObjectTypeInput = ObjectType | Function;
+/** The ONLY token exported to feature scope — the pipe facade. Defined in
+ *  `tokens.ts` (extracted there to break a circular import with
+ *  `records-service.ts` — see that file's module-doc) and re-exported here
+ *  (imported above + re-exported below) so existing importers of
+ *  `RECORD_ENGINE` from `engine.module.js` / the barrel are unaffected. */
+export { RECORD_ENGINE };
+/** The MERGED registration set (read-only metadata) — exposed so the consumer app's
+ *  authz layer can build its own core ModuleRegistry from the SAME collected set,
+ *  without a static import. A plain (non-multi) provider whose value is a snapshot of
+ *  every `forFeature` contribution + the `forRoot` base. Not the sealed pool/uow/
+ *  registry — the wall is intact. */
+export declare const ENGINE_ALL_REGISTRATIONS: unique symbol;
+/** The MERGED access-bundle set (reflected {@link AccessBundleSpec}[]) — exposed so the
+ *  consumer app's authz layer can reconcile declared bundles into its bundle catalog
+ *  from the SAME collected set, without a static import. A plain (non-multi) provider
+ *  whose value is a snapshot of every `forFeature(..., { accessBundles })` contribution.
+ *  Empty when no feature declares a bundle. */
+export declare const ENGINE_ALL_ACCESS_BUNDLES: unique symbol;
+export interface EngineModuleOptions {
+    readonly db: EngineDbConfig;
+    /** Optional code-registered tables. Prefer `EngineModule.forFeature([...])` per
+     *  feature module; anything passed here is merged as a base contribution. */
+    readonly registrations?: readonly ObjectTypeInput[];
+    readonly audit?: AuditSinkConfig;
+    /** Test seam: a deterministic clock. */
+    readonly nowMs?: () => number;
+    /**
+     * OPTIONAL post-delete cascade hook (design §6.2). Called after a successful delete of an
+     * `owned`-type record — the consumer wires guard's `makeShareDeleteCascade()` here to
+     * remove the record's `record_share` rows (no orphan grants). The engine passes the pipe's
+     * TX-BOUND {@link QueryFn} as the FIRST arg so the cascade runs IN THE SAME transaction as
+     * the delete (atomic commit/rollback — mirrors `AuditPort.record(event, query)`). ADR-0003:
+     * the engine never imports guard; this is the injection seam.
+     */
+    readonly onRecordDeleted?: (query: QueryFn, typeKey: string, recordId: string, tenantId: string) => Promise<void>;
+}
+export declare class EngineModule {
+    /**
+     * Register a feature's object tables from WITHIN the feature's own module:
+     * `imports: [EngineModule.forFeature([...myRegistrations])]`. The feature owns its
+     * registrations here and never edits the root module. Stateless glue: no pool, not
+     * global — it only pushes into the module accumulator (see `featureRegistrations`);
+     * `forRoot` reads the accumulated set when it builds the registry.
+     *
+     * Test/multi-container note: contributions accumulate process-globally; call
+     * `EngineModule.resetFeatures()` between isolated container builds in tests.
+     */
+    static forFeature(registrations: readonly ObjectTypeInput[], opts?: {
+        accessBundles?: readonly (AccessBundleSpec | Function)[];
+    }): DynamicModule;
+    /** Test seam: clear the accumulated `forFeature` contributions (for isolated
+     *  container builds — one process normally has one container, so app code needn't). */
+    static resetFeatures(): void;
+    static forRoot(options: EngineModuleOptions): DynamicModule;
+}
+//# sourceMappingURL=engine.module.d.ts.map

package/dist/module/engine.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.module.d.ts","sourceRoot":"","sources":["../../src/module/engine.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAEL,KAAK,aAAa,EAKnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAuC,OAAO,EAAE,MAAM,aAAa,CAAC;AAIhF,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAqB,KAAK,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC7F,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC3F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,0CAA0C,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,QAAQ,CAAC;AAMpD;;;;2EAI2E;AAC3E,OAAO,EAAE,aAAa,EAAE,CAAC;AAEzB;;;;qCAIqC;AACrC,eAAO,MAAM,wBAAwB,eAAqC,CAAC;AAE3E;;;;+CAI+C;AAC/C,eAAO,MAAM,yBAAyB,eAAsC,CAAC;AAmC7E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,cAAc,CAAC;IAC5B;iFAC6E;IAC7E,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IACpD,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;IACjC,wCAAwC;IACxC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CACzB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAYD,qBACa,YAAY;IACvB;;;;;;;;;OASG;IACH,MAAM,CAAC,UAAU,CACf,aAAa,EAAE,SAAS,eAAe,EAAE,EACzC,IAAI,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,SAAS,CAAC,gBAAgB,GAAG,QAAQ,CAAC,EAAE,CAAA;KAAE,GAClE,aAAa;IAMhB;2FACuF;IACvF,MAAM,CAAC,aAAa,IAAI,IAAI;IAK5B,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,aAAa;CAgG5D"}

package/dist/module/engine.module.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * `EngineModule` — the paved road's Nest wiring, and the PHYSICAL WALL.
+ *
+ * It provides EXACTLY ONE thing to feature scope: {@link RECORD_ENGINE} (the
+ * RecordEngine facade). The sealed collaborators — the mariadb pool / UnitOfWork,
+ * the audit sink, the table registry — are providers INTERNAL to this module and
+ * are NOT exported. A feature module that imports EngineModule can inject the engine
+ * facade and nothing else; it is never handed a pool, a query runner, or a
+ * repository. That absence is the wall (the lint rule in the consumer app is the
+ * backstop, not the primary mechanism).
+ *
+ * The permission-gate stage binds to the framework's single decision authority
+ * (guard's `SHIELD_DECISION_AUTHORITY`) — so the engine reuses the ONE decision path,
+ * never its own authz logic.
+ *
+ * OPT-IN + config: `EngineModule.forRoot({ db, registrations })`. The engine opens a
+ * live pool, so (like AuthModule) it is imported only by an app that uses the pipe.
+ * Registrations are code-registered tables loaded at boot.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var EngineModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineModule = exports.ENGINE_ALL_ACCESS_BUNDLES = exports.ENGINE_ALL_REGISTRATIONS = exports.RECORD_ENGINE = void 0;
+const common_1 = require("@nestjs/common");
+const guard_1 = require("@astram/guard");
+const registry_js_1 = require("../registry.js");
+const record_engine_js_1 = require("../pipe/record-engine.js");
+const records_service_js_1 = require("../pipe/records-service.js");
+const tokens_js_1 = require("./tokens.js");
+Object.defineProperty(exports, "RECORD_ENGINE", { enumerable: true, get: function () { return tokens_js_1.RECORD_ENGINE; } });
+const mariadb_unit_of_work_js_1 = require("../adapters/mariadb-unit-of-work.js");
+const mariadb_audit_sink_js_1 = require("../adapters/mariadb-audit-sink.js");
+const object_type_decorator_js_1 = require("../decorators/object-type.decorator.js");
+const access_bundle_decorator_js_1 = require("../decorators/access-bundle.decorator.js");
+/** Normalizer: reflect a decorated class → `ObjectType`; pass a literal through. */
+const toObjectType = (i) => typeof i === 'function' ? (0, object_type_decorator_js_1.reflectObjectType)(i) : i;
+/** The MERGED registration set (read-only metadata) — exposed so the consumer app's
+ *  authz layer can build its own core ModuleRegistry from the SAME collected set,
+ *  without a static import. A plain (non-multi) provider whose value is a snapshot of
+ *  every `forFeature` contribution + the `forRoot` base. Not the sealed pool/uow/
+ *  registry — the wall is intact. */
+exports.ENGINE_ALL_REGISTRATIONS = Symbol('ENGINE_ALL_REGISTRATIONS');
+/** The MERGED access-bundle set (reflected {@link AccessBundleSpec}[]) — exposed so the
+ *  consumer app's authz layer can reconcile declared bundles into its bundle catalog
+ *  from the SAME collected set, without a static import. A plain (non-multi) provider
+ *  whose value is a snapshot of every `forFeature(..., { accessBundles })` contribution.
+ *  Empty when no feature declares a bundle. */
+exports.ENGINE_ALL_ACCESS_BUNDLES = Symbol('ENGINE_ALL_ACCESS_BUNDLES');
+/** Internal tokens (NOT exported — sealed inside the module = the wall). */
+const ENGINE_UOW = Symbol('ENGINE_UOW');
+const ENGINE_AUDIT = Symbol('ENGINE_AUDIT');
+const ENGINE_REGISTRY = Symbol('ENGINE_REGISTRY');
+/**
+ * Module-scoped accumulator for `forFeature` contributions.
+ *
+ * WHY an accumulator and not a `multi: true` DI token: this NestJS version
+ * (@nestjs/core 11.x) has NO multi-provider aggregation — the `multi` flag is
+ * silently ignored and same-token providers last-wins overwrite (proven empirically;
+ * the injector's `addCustomValue`/`addCustomFactory` never read `provider.multi`). So
+ * a DI-collected token cannot gather contributions from sibling `forFeature` modules.
+ *
+ * The accumulator sidesteps DI entirely: `forFeature(...)` is CALLED at
+ * `@Module({ imports: [...] })` array-evaluation time — which, for the whole module
+ * tree, completes BEFORE Nest instantiates any provider. So every `forFeature` has
+ * pushed its registrations before `forRoot`'s registry factory runs, guaranteeing the
+ * full set is present at DI-factory-resolve time (the moment the consumer app's authz
+ * layer needs it). Process-global: one Nest container per process is the norm; the
+ * test suite resets it between cases.
+ */
+const featureRegistrations = [];
+/**
+ * Module-scoped accumulator for `forFeature`'s optional `accessBundles` contributions
+ * — mirrors {@link featureRegistrations} (same before-DI, process-global mechanics). A
+ * feature passes `@AccessBundle` classes (or reflected specs) as the 2nd `forFeature`
+ * arg; `forRoot` reflects + flattens the accumulated set into
+ * {@link ENGINE_ALL_ACCESS_BUNDLES}.
+ */
+const accessBundleRegistrations = [];
+/** Lifecycle holder so the sealed pool is closed on shutdown. */
+let EngineLifecycle = class EngineLifecycle {
+    uow;
+    constructor(uow) {
+        this.uow = uow;
+    }
+    async onModuleDestroy() {
+        const maybeClosable = this.uow;
+        if (typeof maybeClosable.close === 'function')
+            await maybeClosable.close();
+    }
+};
+EngineLifecycle = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(ENGINE_UOW)),
+    __metadata("design:paramtypes", [Object])
+], EngineLifecycle);
+let EngineModule = EngineModule_1 = class EngineModule {
+    /**
+     * Register a feature's object tables from WITHIN the feature's own module:
+     * `imports: [EngineModule.forFeature([...myRegistrations])]`. The feature owns its
+     * registrations here and never edits the root module. Stateless glue: no pool, not
+     * global — it only pushes into the module accumulator (see `featureRegistrations`);
+     * `forRoot` reads the accumulated set when it builds the registry.
+     *
+     * Test/multi-container note: contributions accumulate process-globally; call
+     * `EngineModule.resetFeatures()` between isolated container builds in tests.
+     */
+    static forFeature(registrations, opts) {
+        featureRegistrations.push(registrations);
+        accessBundleRegistrations.push(opts?.accessBundles ?? []);
+        return { module: EngineModule_1 };
+    }
+    /** Test seam: clear the accumulated `forFeature` contributions (for isolated
+     *  container builds — one process normally has one container, so app code needn't). */
+    static resetFeatures() {
+        featureRegistrations.length = 0;
+        accessBundleRegistrations.length = 0;
+    }
+    static forRoot(options) {
+        // The full set = every forFeature contribution (already accumulated at module-eval
+        // time, before DI) + an optional forRoot base (backward-compat with the old
+        // `forRoot({registrations})` API). Snapshot NOW (forRoot-call time is after all
+        // sibling forFeature calls in the same @Module imports have evaluated).
+        const allRegistrations = [
+            ...featureRegistrations.flat(),
+            ...(options.registrations ?? []),
+        ].map(toObjectType);
+        // The registry is built from the merged set. Behavior identical to before — same
+        // register() per registration (just from the collected set, not options only).
+        const registryProvider = {
+            provide: ENGINE_REGISTRY,
+            useFactory: () => {
+                const registry = new registry_js_1.TableRegistry();
+                for (const reg of allRegistrations)
+                    registry.register(reg);
+                return registry;
+            },
+        };
+        // The merged registration set, exposed (read-only) for the app's authz layer to
+        // build its own core ModuleRegistry from the same set (no static import).
+        const allRegistrationsProvider = {
+            provide: exports.ENGINE_ALL_REGISTRATIONS,
+            useValue: allRegistrations,
+        };
+        // Snapshot the accumulated access-bundle contributions (same before-DI ordering
+        // guarantee as registrations): reflect any decorated class → `AccessBundleSpec`,
+        // pass a literal spec through. Exposed read-only for the app's bundle reconciler.
+        const allBundles = accessBundleRegistrations
+            .flat()
+            .map((b) => (typeof b === 'function' ? (0, access_bundle_decorator_js_1.reflectAccessBundle)(b) : b));
+        const allBundlesProvider = {
+            provide: exports.ENGINE_ALL_ACCESS_BUNDLES,
+            useValue: allBundles,
+        };
+        const uowProvider = {
+            provide: ENGINE_UOW,
+            useFactory: () => new mariadb_unit_of_work_js_1.MariaDbUnitOfWork(options.db),
+        };
+        const auditProvider = {
+            provide: ENGINE_AUDIT,
+            useFactory: () => new mariadb_audit_sink_js_1.MariaDbAuditSink(options.audit ?? {}),
+        };
+        const engineProvider = {
+            provide: tokens_js_1.RECORD_ENGINE,
+            useFactory: (registry, uow, decision, audit) => {
+                const deps = {
+                    registry,
+                    uow,
+                    decision,
+                    audit,
+                    ...(options.nowMs ? { nowMs: options.nowMs } : {}),
+                    ...(options.onRecordDeleted ? { onRecordDeleted: options.onRecordDeleted } : {}),
+                };
+                return new record_engine_js_1.RecordEngineImpl(deps);
+            },
+            inject: [ENGINE_REGISTRY, ENGINE_UOW, guard_1.SHIELD_DECISION_AUTHORITY, ENGINE_AUDIT],
+        };
+        return {
+            module: EngineModule_1,
+            // Global so the RecordEngine facade is injectable app-wide (like the framework's
+            // decision authority) — a feature module injects RECORD_ENGINE without having to
+            // re-import a dynamic forRoot(). The WALL is unaffected: still ONLY the facade is
+            // exported; the sealed pool/uow/audit/registry remain module-internal.
+            global: true,
+            providers: [
+                registryProvider,
+                allRegistrationsProvider,
+                allBundlesProvider,
+                uowProvider,
+                auditProvider,
+                engineProvider,
+                EngineLifecycle,
+                records_service_js_1.RecordsService,
+            ],
+            // ⛔ WALL: the facade + the read-only merged registration + access-bundle lists.
+            // The pool/uow/audit/registry tokens are deliberately NOT exported — feature
+            // scope cannot inject them. `RecordsService` is a request-scoped facade OVER
+            // `RECORD_ENGINE` (reads req.principal, forwards as actor) — safe to export
+            // alongside it; it exposes no pool/uow/audit/registry access itself.
+            exports: [tokens_js_1.RECORD_ENGINE, exports.ENGINE_ALL_REGISTRATIONS, exports.ENGINE_ALL_ACCESS_BUNDLES, records_service_js_1.RecordsService],
+        };
+    }
+};
+exports.EngineModule = EngineModule;
+exports.EngineModule = EngineModule = EngineModule_1 = __decorate([
+    (0, common_1.Module)({})
+], EngineModule);

package/dist/module/engine.module.js.map

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

package/dist/module/tokens.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DI tokens shared between `engine.module.ts` and framework-facing consumers
+ * (e.g. `records-service.ts`) that need the token WITHOUT importing the module
+ * file itself. Extracted to break a circular import: `engine.module.ts` will
+ * import `RecordsService` (to register + export it), and `records-service.ts`
+ * needs `RECORD_ENGINE` — if the token stayed in `engine.module.ts`, that would
+ * be a cycle. Both files import the token from here instead; only
+ * `engine.module.ts` imports `RecordsService` (one direction).
+ */
+/** The ONLY token exported to feature scope — the pipe facade. */
+export declare const RECORD_ENGINE: unique symbol;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/module/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/module/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,kEAAkE;AAClE,eAAO,MAAM,aAAa,eAA0B,CAAC"}

package/dist/module/tokens.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * DI tokens shared between `engine.module.ts` and framework-facing consumers
+ * (e.g. `records-service.ts`) that need the token WITHOUT importing the module
+ * file itself. Extracted to break a circular import: `engine.module.ts` will
+ * import `RecordsService` (to register + export it), and `records-service.ts`
+ * needs `RECORD_ENGINE` — if the token stayed in `engine.module.ts`, that would
+ * be a cycle. Both files import the token from here instead; only
+ * `engine.module.ts` imports `RecordsService` (one direction).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORD_ENGINE = void 0;
+/** The ONLY token exported to feature scope — the pipe facade. */
+exports.RECORD_ENGINE = Symbol('RECORD_ENGINE');