@entifix/static 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r10c Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,30 @@
-# Temporary Holding Version
+# @entifix/static
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A read-only `EntityRepository` over records bundled with the build — the content of a static-export site, served through the ordinary use cases and swappable for `@entifix/rest` the day a backend appears.
+
+`get` and `load` have the Mongo adapter's semantics: every filter operator, groups, array membership, a dotted path into one locale of a `localized` member, multi-key sorting and 1-based paging. `save` and `delete` fail with an `EntifixLogicError`, because a static source is read-only.
+
+Records that arrive as JSON are checked against the entity's metadata before anything is served (`validRecordsOrThrow` from `@entifix/core`): identity, `required`, member types, dates, link ids, item counts, `notBefore`, cardinality and localized completeness. Every problem is thrown together, so a broken record fails the build instead of a visitor's page.
+
+```ts
+const posts = staticRepositoryFromRecords(Post, postsJson, {
+  source: 'posts.json',
+  linkTargets: { tags: new Set(tagsJson.map(tag => tag.id)) },
+});
+```
+
+## Install
+
+```sh
+pnpm add @entifix/static effect
+```
+
+## Entry points
+
+| Import            | What it holds                                         |
+| ----------------- | ----------------------------------------------------- |
+| `@entifix/static` | `makeStaticRepository`, `staticRepositoryFromRecords` |
+
+---
+
+Tier 2 (adapters) of entifix — a package depends only on its own tier or below. See [the tiers](https://github.com/r10c-technologies/entifix#the-tiers-and-what-you-are-allowed-to-install). MIT licensed.

package/dist/from-records.d.ts

@@ -0,0 +1,19 @@
+import type { EntityRepository } from '@entifix/business';
+import { type Entity, type EntityConstructor, type ValidateRecordsOptions } from '@entifix/core';
+import { type StaticRepositoryOptions } from './static-repository.js';
+export type StaticRecordsOptions = ValidateRecordsOptions & StaticRepositoryOptions;
+/**
+ * A static repository over untyped records — the JSON a build bundles —
+ * checked against the entity's metadata before anything is served.
+ *
+ * The mapping assigns every non-relation value raw, so a record that is wrong
+ * would otherwise reach a reader as `undefined` mid-page, or a date as a
+ * string. `validRecordsOrThrow` from core runs first instead: identity,
+ * `required`, each member's type, dates parsed, link ids against the targets
+ * given, item counts, `notBefore`, cardinality, localized completeness, the
+ * caller's rules — every problem collected, and thrown together as a
+ * `RecordValidationError`, so a broken record fails the build rather than a
+ * visitor's page.
+ */
+export declare function staticRepositoryFromRecords<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, records: readonly unknown[], options?: StaticRecordsOptions): EntityRepository;
+//# sourceMappingURL=from-records.d.ts.map

package/dist/from-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-records.d.ts","sourceRoot":"","sources":["../src/from-records.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAE5B,MAAM,eAAe,CAAC;AAGvB,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,GACvD,uBAAuB,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,SAAS,MAAM,EAChE,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,OAAO,GAAE,oBAAyB,GACjC,gBAAgB,CAMlB"}

package/dist/from-records.js

@@ -0,0 +1,22 @@
+import { deserializeEntityCollection, validRecordsOrThrow } from '@entifix/core';
+import { Effect } from 'effect';
+import { makeStaticRepository } from './static-repository.js';
+/**
+ * A static repository over untyped records — the JSON a build bundles —
+ * checked against the entity's metadata before anything is served.
+ *
+ * The mapping assigns every non-relation value raw, so a record that is wrong
+ * would otherwise reach a reader as `undefined` mid-page, or a date as a
+ * string. `validRecordsOrThrow` from core runs first instead: identity,
+ * `required`, each member's type, dates parsed, link ids against the targets
+ * given, item counts, `notBefore`, cardinality, localized completeness, the
+ * caller's rules — every problem collected, and thrown together as a
+ * `RecordValidationError`, so a broken record fails the build rather than a
+ * visitor's page.
+ */ export function staticRepositoryFromRecords(entityConstructor, records, options = {}) {
+    const valid = validRecordsOrThrow(entityConstructor, records, options);
+    const instances = Effect.runSync(deserializeEntityCollection(entityConstructor, valid));
+    return makeStaticRepository(entityConstructor, instances, options);
+}
+
+//# sourceMappingURL=from-records.js.map

package/dist/from-records.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/from-records.ts"],"sourcesContent":["import type { EntityRepository } from '@entifix/business';\nimport {\n  deserializeEntityCollection,\n  type Entity,\n  type EntityConstructor,\n  type ValidateRecordsOptions,\n  validRecordsOrThrow,\n} from '@entifix/core';\nimport { Effect } from 'effect';\n\nimport {\n  makeStaticRepository,\n  type StaticRepositoryOptions,\n} from './static-repository.js';\n\nexport type StaticRecordsOptions = ValidateRecordsOptions &\n  StaticRepositoryOptions;\n\n/**\n * A static repository over untyped records — the JSON a build bundles —\n * checked against the entity's metadata before anything is served.\n *\n * The mapping assigns every non-relation value raw, so a record that is wrong\n * would otherwise reach a reader as `undefined` mid-page, or a date as a\n * string. `validRecordsOrThrow` from core runs first instead: identity,\n * `required`, each member's type, dates parsed, link ids against the targets\n * given, item counts, `notBefore`, cardinality, localized completeness, the\n * caller's rules — every problem collected, and thrown together as a\n * `RecordValidationError`, so a broken record fails the build rather than a\n * visitor's page.\n */\nexport function staticRepositoryFromRecords<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  records: readonly unknown[],\n  options: StaticRecordsOptions = {},\n): EntityRepository {\n  const valid = validRecordsOrThrow(entityConstructor, records, options);\n  const instances = Effect.runSync(\n    deserializeEntityCollection(entityConstructor, valid),\n  ) as TEntity[];\n  return makeStaticRepository(entityConstructor, instances, options);\n}\n"],"names":["deserializeEntityCollection","validRecordsOrThrow","Effect","makeStaticRepository","staticRepositoryFromRecords","entityConstructor","records","options","valid","instances","runSync"],"mappings":"AACA,SACEA,2BAA2B,EAI3BC,mBAAmB,QACd,gBAAgB;AACvB,SAASC,MAAM,QAAQ,SAAS;AAEhC,SACEC,oBAAoB,QAEf,yBAAyB;AAKhC;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,4BACdC,iBAA6C,EAC7CC,OAA2B,EAC3BC,UAAgC,CAAC,CAAC;IAElC,MAAMC,QAAQP,oBAAoBI,mBAAmBC,SAASC;IAC9D,MAAME,YAAYP,OAAOQ,OAAO,CAC9BV,4BAA4BK,mBAAmBG;IAEjD,OAAOL,qBAAqBE,mBAAmBI,WAAWF;AAC5D"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './from-records.js';
+export * from './static-repository.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,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './from-records.js';
+export * from './static-repository.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './from-records.js';\nexport * from './static-repository.js';\n"],"names":[],"mappings":"AAAA,cAAc,oBAAoB;AAClC,cAAc,yBAAyB"}

package/dist/static-repository.d.ts

@@ -0,0 +1,24 @@
+import type { EntityRepository } from '@entifix/business';
+import { type Entity, type EntityConstructor } from '@entifix/core';
+export interface StaticRepositoryOptions {
+    /** The name an error message uses. Defaults to the entity's class name. */
+    readonly label?: string;
+}
+/**
+ * A read-only {@link EntityRepository} over records held in memory — content
+ * bundled with a static build, served through the ordinary use cases, and
+ * swappable for a REST adapter the day a backend appears.
+ *
+ * `get` and `load` carry the Mongo adapter's semantics, from core's in-memory
+ * query evaluation: every filter operator, groups, array membership, a dotted
+ * path into a localized member, multi-key sorting, and 1-based paging that
+ * defaults to ten. Both hand out copies.
+ *
+ * `save` and `delete` fail with an `EntifixLogicError`: a static source is
+ * read-only, and pretending otherwise is worse than refusing.
+ *
+ * It holds instances. Records that arrive as JSON go through
+ * {@link staticRepositoryFromRecords}, which validates them first.
+ */
+export declare function makeStaticRepository<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, records: readonly TEntity[], { label }?: StaticRepositoryOptions): EntityRepository;
+//# sourceMappingURL=static-repository.d.ts.map

package/dist/static-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-repository.d.ts","sourceRoot":"","sources":["../src/static-repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAOL,KAAK,MAAM,EACX,KAAK,iBAAiB,EAMvB,MAAM,eAAe,CAAC;AAkCvB,MAAM,WAAW,uBAAuB;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,MAAM,EACzD,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,EAAE,KAA8B,EAAE,GAAE,uBAA4B,GAC/D,gBAAgB,CA0DlB"}

package/dist/static-repository.js

@@ -0,0 +1,73 @@
+import { applyFiltering, applySorting, deserializeSingleEntity, EntifixConnError, EntifixLogicError, extractMetaAccessors, serializeEntity } from '@entifix/core';
+import { Effect } from 'effect';
+/** The Mongo adapter's defaults, which this one copies exactly. */ const DEFAULT_PAGE = 1;
+const DEFAULT_PAGE_SIZE = 10;
+/**
+ * A copy of a record, so a caller can never reach into the store.
+ *
+ * Through the entity's own mapping — serialize, then deserialize — as a real
+ * adapter maps every record on the way out. An entity with no accessors has no
+ * mapping to go through, so it is copied member by member instead.
+ */ function copyOf(record) {
+    const entityConstructor = record.constructor;
+    if (extractMetaAccessors(entityConstructor).length === 0) {
+        return Effect.succeed(Object.assign(Object.create(Object.getPrototypeOf(record)), record));
+    }
+    // `undefined` only comes back for `null`/`undefined` input, and
+    // `serializeEntity` always hands over an object.
+    return deserializeSingleEntity(entityConstructor, serializeEntity(entityConstructor, record));
+}
+/**
+ * A read-only {@link EntityRepository} over records held in memory — content
+ * bundled with a static build, served through the ordinary use cases, and
+ * swappable for a REST adapter the day a backend appears.
+ *
+ * `get` and `load` carry the Mongo adapter's semantics, from core's in-memory
+ * query evaluation: every filter operator, groups, array membership, a dotted
+ * path into a localized member, multi-key sorting, and 1-based paging that
+ * defaults to ten. Both hand out copies.
+ *
+ * `save` and `delete` fail with an `EntifixLogicError`: a static source is
+ * read-only, and pretending otherwise is worse than refusing.
+ *
+ * It holds instances. Records that arrive as JSON go through
+ * {@link staticRepositoryFromRecords}, which validates them first.
+ */ export function makeStaticRepository(entityConstructor, records, { label = entityConstructor.name } = {}) {
+    const stored = [
+        ...records
+    ];
+    const readOnly = (verb)=>Effect.fail(new EntifixLogicError(`Cannot ${verb} a ${label}: it is served from static content, which is read-only`, undefined, {
+            entity: label,
+            operation: verb
+        }));
+    const get = (id)=>{
+        const found = stored.find((record)=>record.id === id);
+        return found === undefined ? Effect.fail(new EntifixConnError('Entity not found', undefined, {
+            entity: label,
+            id
+        })) : copyOf(found);
+    };
+    const load = (request)=>Effect.suspend(()=>{
+            var _request_page, _request_pageSize;
+            const matched = applySorting(applyFiltering(stored, request.filtering), request.sorting);
+            const page = (_request_page = request.page) != null ? _request_page : DEFAULT_PAGE;
+            const pageSize = (_request_pageSize = request.pageSize) != null ? _request_pageSize : DEFAULT_PAGE_SIZE;
+            const start = (page - 1) * pageSize;
+            return Effect.forEach(matched.slice(start, start + pageSize), copyOf).pipe(Effect.map((items)=>({
+                    items,
+                    total: matched.length,
+                    request
+                })));
+        });
+    // Each method closes over its own state, so nothing is required from the
+    // Effect environment; that is assignable to the port's channel, and the
+    // cast keeps its generic signatures, as entifix's other adapters do.
+    return {
+        get,
+        load,
+        save: ()=>readOnly('save'),
+        delete: ()=>readOnly('delete')
+    };
+}
+
+//# sourceMappingURL=static-repository.js.map

package/dist/static-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/static-repository.ts"],"sourcesContent":["import type { EntityRepository } from '@entifix/business';\nimport {\n  applyFiltering,\n  applySorting,\n  deserializeSingleEntity,\n  EntifixConnError,\n  type EntifixError,\n  EntifixLogicError,\n  type Entity,\n  type EntityConstructor,\n  type EntityId,\n  type EntityLoadRequest,\n  type EntityPage,\n  extractMetaAccessors,\n  serializeEntity,\n} from '@entifix/core';\nimport { Effect } from 'effect';\n\n/** The Mongo adapter's defaults, which this one copies exactly. */\nconst DEFAULT_PAGE = 1;\nconst DEFAULT_PAGE_SIZE = 10;\n\n/**\n * A copy of a record, so a caller can never reach into the store.\n *\n * Through the entity's own mapping — serialize, then deserialize — as a real\n * adapter maps every record on the way out. An entity with no accessors has no\n * mapping to go through, so it is copied member by member instead.\n */\nfunction copyOf<TEntity extends Entity>(\n  record: TEntity,\n): Effect.Effect<TEntity, EntifixError> {\n  const entityConstructor = record.constructor as EntityConstructor<TEntity>;\n  if (extractMetaAccessors(entityConstructor).length === 0) {\n    return Effect.succeed(\n      Object.assign(\n        Object.create(Object.getPrototypeOf(record) as object) as TEntity,\n        record,\n      ),\n    );\n  }\n  // `undefined` only comes back for `null`/`undefined` input, and\n  // `serializeEntity` always hands over an object.\n  return deserializeSingleEntity(\n    entityConstructor,\n    serializeEntity(entityConstructor, record),\n  ) as Effect.Effect<TEntity, EntifixError>;\n}\n\nexport interface StaticRepositoryOptions {\n  /** The name an error message uses. Defaults to the entity's class name. */\n  readonly label?: string;\n}\n\n/**\n * A read-only {@link EntityRepository} over records held in memory — content\n * bundled with a static build, served through the ordinary use cases, and\n * swappable for a REST adapter the day a backend appears.\n *\n * `get` and `load` carry the Mongo adapter's semantics, from core's in-memory\n * query evaluation: every filter operator, groups, array membership, a dotted\n * path into a localized member, multi-key sorting, and 1-based paging that\n * defaults to ten. Both hand out copies.\n *\n * `save` and `delete` fail with an `EntifixLogicError`: a static source is\n * read-only, and pretending otherwise is worse than refusing.\n *\n * It holds instances. Records that arrive as JSON go through\n * {@link staticRepositoryFromRecords}, which validates them first.\n */\nexport function makeStaticRepository<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  records: readonly TEntity[],\n  { label = entityConstructor.name }: StaticRepositoryOptions = {},\n): EntityRepository {\n  const stored = [...records];\n\n  const readOnly = (verb: string) =>\n    Effect.fail(\n      new EntifixLogicError(\n        `Cannot ${verb} a ${label}: it is served from static content, which is read-only`,\n        undefined,\n        { entity: label, operation: verb },\n      ),\n    );\n\n  const get = (id: EntityId) => {\n    const found = stored.find(record => record.id === id);\n    return found === undefined\n      ? Effect.fail(\n          new EntifixConnError('Entity not found', undefined, {\n            entity: label,\n            id,\n          }),\n        )\n      : copyOf(found);\n  };\n\n  const load = (request: EntityLoadRequest<TEntity>) =>\n    Effect.suspend(() => {\n      const matched = applySorting(\n        applyFiltering(stored, request.filtering),\n        request.sorting,\n      );\n      const page = request.page ?? DEFAULT_PAGE;\n      const pageSize = request.pageSize ?? DEFAULT_PAGE_SIZE;\n      const start = (page - 1) * pageSize;\n\n      return Effect.forEach(\n        matched.slice(start, start + pageSize),\n        copyOf,\n      ).pipe(\n        Effect.map(\n          items =>\n            ({\n              items,\n              total: matched.length,\n              request,\n            }) satisfies EntityPage<TEntity>,\n        ),\n      );\n    });\n\n  // Each method closes over its own state, so nothing is required from the\n  // Effect environment; that is assignable to the port's channel, and the\n  // cast keeps its generic signatures, as entifix's other adapters do.\n  return {\n    get,\n    load,\n    save: () => readOnly('save'),\n    delete: () => readOnly('delete'),\n  } as unknown as EntityRepository;\n}\n"],"names":["applyFiltering","applySorting","deserializeSingleEntity","EntifixConnError","EntifixLogicError","extractMetaAccessors","serializeEntity","Effect","DEFAULT_PAGE","DEFAULT_PAGE_SIZE","copyOf","record","entityConstructor","length","succeed","Object","assign","create","getPrototypeOf","makeStaticRepository","records","label","name","stored","readOnly","verb","fail","undefined","entity","operation","get","id","found","find","load","request","suspend","matched","filtering","sorting","page","pageSize","start","forEach","slice","pipe","map","items","total","save","delete"],"mappings":"AACA,SACEA,cAAc,EACdC,YAAY,EACZC,uBAAuB,EACvBC,gBAAgB,EAEhBC,iBAAiB,EAMjBC,oBAAoB,EACpBC,eAAe,QACV,gBAAgB;AACvB,SAASC,MAAM,QAAQ,SAAS;AAEhC,iEAAiE,GACjE,MAAMC,eAAe;AACrB,MAAMC,oBAAoB;AAE1B;;;;;;CAMC,GACD,SAASC,OACPC,MAAe;IAEf,MAAMC,oBAAoBD,OAAO,WAAW;IAC5C,IAAIN,qBAAqBO,mBAAmBC,MAAM,KAAK,GAAG;QACxD,OAAON,OAAOO,OAAO,CACnBC,OAAOC,MAAM,CACXD,OAAOE,MAAM,CAACF,OAAOG,cAAc,CAACP,UACpCA;IAGN;IACA,gEAAgE;IAChE,iDAAiD;IACjD,OAAOT,wBACLU,mBACAN,gBAAgBM,mBAAmBD;AAEvC;AAOA;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASQ,qBACdP,iBAA6C,EAC7CQ,OAA2B,EAC3B,EAAEC,QAAQT,kBAAkBU,IAAI,EAA2B,GAAG,CAAC,CAAC;IAEhE,MAAMC,SAAS;WAAIH;KAAQ;IAE3B,MAAMI,WAAW,CAACC,OAChBlB,OAAOmB,IAAI,CACT,IAAItB,kBACF,CAAC,OAAO,EAAEqB,KAAK,GAAG,EAAEJ,MAAM,sDAAsD,CAAC,EACjFM,WACA;YAAEC,QAAQP;YAAOQ,WAAWJ;QAAK;IAIvC,MAAMK,MAAM,CAACC;QACX,MAAMC,QAAQT,OAAOU,IAAI,CAACtB,CAAAA,SAAUA,OAAOoB,EAAE,KAAKA;QAClD,OAAOC,UAAUL,YACbpB,OAAOmB,IAAI,CACT,IAAIvB,iBAAiB,oBAAoBwB,WAAW;YAClDC,QAAQP;YACRU;QACF,MAEFrB,OAAOsB;IACb;IAEA,MAAME,OAAO,CAACC,UACZ5B,OAAO6B,OAAO,CAAC;gBAKAD,eACIA;YALjB,MAAME,UAAUpC,aACdD,eAAeuB,QAAQY,QAAQG,SAAS,GACxCH,QAAQI,OAAO;YAEjB,MAAMC,QAAOL,gBAAAA,QAAQK,IAAI,YAAZL,gBAAgB3B;YAC7B,MAAMiC,YAAWN,oBAAAA,QAAQM,QAAQ,YAAhBN,oBAAoB1B;YACrC,MAAMiC,QAAQ,AAACF,CAAAA,OAAO,CAAA,IAAKC;YAE3B,OAAOlC,OAAOoC,OAAO,CACnBN,QAAQO,KAAK,CAACF,OAAOA,QAAQD,WAC7B/B,QACAmC,IAAI,CACJtC,OAAOuC,GAAG,CACRC,CAAAA,QACG,CAAA;oBACCA;oBACAC,OAAOX,QAAQxB,MAAM;oBACrBsB;gBACF,CAAA;QAGR;IAEF,yEAAyE;IACzE,wEAAwE;IACxE,qEAAqE;IACrE,OAAO;QACLL;QACAI;QACAe,MAAM,IAAMzB,SAAS;QACrB0B,QAAQ,IAAM1B,SAAS;IACzB;AACF"}

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@entifix/static",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.0",
+  "description": "A read-only entity repository over records bundled with the build: Mongo's query semantics, records validated against entity metadata before they are served.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/ts/static"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "nx": {
+    "tags": [
+      "tier:2"
+    ],
+    "sourceRoot": "packages/ts/static/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/ts/static/dist",
+          "main": "packages/ts/static/src/index.ts",
+          "tsConfig": "packages/ts/static/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.23",
+    "@entifix/business": "0.3.0",
+    "@entifix/core": "0.3.0"
+  },
+  "devDependencies": {
+    "effect": "4.0.5",
+    "@entifix/testing-unit": "0.3.0"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.5"
+  }
 }