@ng-org/orm 0.1.2-alpha.10 → 0.1.2-alpha.12

package/README.md

@@ -29,6 +29,8 @@ Note that we support discrete (**JSON**) CRDT and graph (**RDF**) CRDT ORMs.
 - [Working with Data](#working-with-data)
     - [Creating a Document](#creating-a-document)
     - [Using and Modifying ORM Objects](#using-and-modifying-orm-objects)
+    - [The (Discrete)OrmSubscription Class](#the-discreteormsubscription-class)
+        - [The DeepSignal\<\> type](#the-deepsignal-type)
         - [Graph ORM: Relationships](#graph-orm-relationships)
 
 ---
@@ -49,7 +51,24 @@ pnpm add -D @ng-org/shex-orm
 
 ## Start
 
-You are strongly advised to look at the example apps for [discrete JSON documents](https://git.nextgraph.org/NextGraph/expense-tracker-discrete) and [typed graph documents](https://git.nextgraph.org/NextGraph/expense-tracker-graph).
+Before writing your own app, you are strongly advised to look at the example apps below, where you can find framework and crdt-specific walkthroughs.
+
+- Discrete CRDTs
+    - [all frameworks running in the same window with Astro](https://git.nextgraph.org/NextGraph/expense-tracker-discrete)
+    - [Svelte 5 Runes](https://git.nextgraph.org/NextGraph/expense-tracker-discrete-svelte)
+    - [Svelte 3/4](https://git.nextgraph.org/NextGraph/expense-tracker-discrete-svelte4)
+    - [Vue](https://git.nextgraph.org/NextGraph/expense-tracker-discrete-vue)
+    - [React](https://git.nextgraph.org/NextGraph/expense-tracker-discrete-react)
+- RDF/Graph CRDT
+    - [all frameworks running in the same window with Astro](https://git.nextgraph.org/NextGraph/expense-tracker-graph)
+    - [Svelte 5 Runes](https://git.nextgraph.org/NextGraph/expense-tracker-graph-svelte)
+    - [Svelte 3/4](https://git.nextgraph.org/NextGraph/expense-tracker-graph-svelte4)
+    - [Vue](https://git.nextgraph.org/NextGraph/expense-tracker-graph-vue)
+    - [React](https://git.nextgraph.org/NextGraph/expense-tracker-graph-react)
+
+The app looks the same in all implementations. You can see that the `useShape()` and `useDiscrete()` frontend hooks that interact with the data, share the same syntax across all frameworks.
+
+---
 
 Before using the ORM, initialize NextGraph in your app entry point:
 
@@ -57,9 +76,14 @@ Before using the ORM, initialize NextGraph in your app entry point:
 import { ng, init } from "@ng-org/web";
 import { initNg } from "@ng-org/orm";
 
+// Call init as early as possible when your app loads.
+// At the first call, it will redirect the user to login with their wallet.
+// In that case, there is no need to render the rest of the app.
+// Then your app will reload, and this time, this call back will be called:
 await init(
     async (event) => {
-        // The ORM needs to have access to ng, the interface to the engine running in WASM.
+        // The ORM needs to have access to ng,
+        // the interface to the engine running in WASM.
         initNg(ng, event.session);
     },
     true,
@@ -67,19 +91,7 @@ await init(
 );
 ```
 
-Then use `useShape()` for graphs, or `useDiscrete()` for discrete documents.
-
-In some cases, you may want to use advanced features managing subscriptions with the engine.
-With an OrmSubscription, you can manage things like transactions manually.
-This is useful for example when you want to manage a state across components.
-See [`OrmSubscription.getOrCreate(ShapeType, scope)`](#getorcreate-1) for graphs
-and [`DiscreteOrmSubscription.getOrCreate(documentId)`](#getorcreate) for discrete documents.
-
-Internally, the OrmSubscription keeps a signalObject, a proxied, reactive object. When modifications are made, this makes the frontend components rerender and sends the update to the engine to be persisted.
-
-In all cases, you have to create a document first with `ng.doc_create()`.
-
-## Graph ORM: Defining Schemas
+## RDF (graph) ORM: Defining Schemas
 
 Define your data model using [SHEX (Shape Expressions)](https://shex.io/):
 See [@ng-org/shex-orm](../shex-orm/README.md) for details.
@@ -95,15 +107,18 @@ ex:Dog {
     ex:name xsd:string ;
     ex:age xsd:integer ? ;
     ex:toys xsd:string * ;
+    ex:owner IRI ? ;
 }
 ```
 
-Generate TypeScript types. Add the following to your `package.json` scripts and run `build:orm`:
+Add the following to your `package.json` scripts and run `build:orm` (assuming you installed `@ng-org/shex-orm` as dev dependency):
 
 ```json
 "build:orm": "rdf-orm build --input ./src/shapes/shex --output ./src/shapes/orm"
 ```
 
+This will generate three files: one for TypeScript type definitions, one with generated schemas, and one that exports objects with the schema, type definition and shape name: The so called _shape types_. When you request data from the engine, you will pass a shape type in your request that defines what your object looks like.
+
 ## Frontend Framework Usage
 
 The SDK offers hooks for discrete and graph-based CRDTs for Svelte, Vue and React:
@@ -119,21 +134,25 @@ The SDK offers hooks for discrete and graph-based CRDTs for Svelte, Vue and Reac
     - Vue: [useShape](#vueuseshape)
     - React: [useShape](#reactuseshape)
 
-All of them have the same logic. They create a 2-way binding to the engine.
+All of them share the same logic. They create a 2-way binding to the engine.
 You can modify the returned object like any other JSON object. Changes are immediately
-reflected in the CRDT and the components rerender.
+reflected in the CRDT and the components refresh.
 When the component unmounts, the subscription is closed.
 
 ```ts
 // Queries the graphs with NURI did:ng:o:g1 and did:ng:o:g2 and with subject s1 or s2.
-const expenses: DeepSignal<Set<Expense>> = useShape(ExpenseShapeType, {
+const expenses = useShape(ExpenseShapeType, {
     graphs: ["did:ng:o:g1", "did:ng:o:g2"],
     subjects: ["<s1 IRI>", "<s2 IRI>"],
 });
+// Note: While the returned `expenses` object has type `DeepSignal<Set<Expense>>`, you can treat and type it as `Set<Expense>` as well, for convenience.
+
+// Now you can use expenses in your component
+// and modify them to trigger a refresh and persist them.
 
-// Use expenses in your component
-// and modify them to trigger a rerender and persist them.
-// ...
+// In analogy:
+const expense: DeepSignal<Expense[]> = useDiscrete(expenseDocumentNuri);
+// Note: While the returned `expenses` object has type `DeepSignal<Expense[]>`, you can treat and type it as `Expense[]` as well, for convenience.
 ```
 
 ---
@@ -143,7 +162,7 @@ const expenses: DeepSignal<Set<Expense>> = useShape(ExpenseShapeType, {
 The ORM is designed to make working with data as normal as possible.
 You get an object as you are used to it and when you change properties,
 they are automatically persisted and synced with other devices. Conversely,
-modifications arrive at the ORM objects immediately and your components rerender.
+modifications coming from other devices update the ORM objects too and your components refresh.
 
 ### Creating a Document
 
@@ -168,7 +187,7 @@ await ng.sparql_update(
 );
 ```
 
-To find your document, you can make a sparql query as well:
+To find your document NURI, you make a sparql query:
 
 ```ts
 const ret = await ng.sparql_query(
@@ -184,9 +203,31 @@ let documentId = ret?.results.bindings?.[0]?.storeId?.value;
 
 There are multiple ways to get and modify data:
 
-- Get and modify the data returned by a `useShape()` or `useDiscrete()` hook inside a component.
-- Get and modify the signalObject of the subscription returned by `Orm(Discrete)Subscription.getOrCreate()`.
-- For graph ORMs: Call [`insertObject()`](#insertobject) or [`getObjects`](#getobjects) (no 2-way binding).
+- Get and modify the signalObject of the subscription returned by [`Orm(Discrete)Subscription.getOrCreate()`](#the-discreteormsubscription-class).
+- Get and modify the data returned by a `useShape()` or `useDiscrete()` hook inside of a component.
+- For graph ORMs (no 2-way binding):
+    - [`getObjects(shapeType, scope)`](#getobjects) Gets all object with the given shape type within the `scope`. The returned objects are _not_ `DeepSignal` objects - modifications to them do not trigger updates and changes from other sources do not update the returned object.
+    - [`insertObject(shapeType, object)`](#insertobject): A convenience function to add objects of a given shape to the database. While with `useShape()` and `OrmSubscription`, you can just add objects to the returned set or `subscription.signalObject`, respectively.
+      This function spares you of creating an `OrmSubscription` and can be used outside of components, where you can't call `useShape`.
+
+### The (Discrete)OrmSubscription Class
+
+You can establish subscriptions outside of frontend components using the (Discrete)OrmSubscription class. DiscreteOrmSubscriptions are scoped to one document, (RDF-based) OrmSubscriptions can have a `Scope` of more than one document and require a shape type. Once a subscription is established, its `.readyPromise` resolves and the `.signalObject` contains the 2-way bound data.
+
+You can create a new subscription using `(Discrete)OrmSubscription.getOrCreate()`. If a subscription with the same document or scope exists already, a reference to that object is returned. Otherwise, a new one is created.
+The pooling is especially useful when more than one frontend component subscribes to the same data and scope by calling `useShape()` or `useDiscrete()`. This reduces load and the data is available instantly.
+
+Subscriptions are open until `.close()` is called on all references of this object. The `useShape` and `useDiscrete` hooks call `.close()` on their reference when their component unmounts.
+
+### Transactions
+
+To improve performance, you can start transactions with subscriptions using `.beginTransaction()` and `.commitTransaction()`. This will delay the persistence until `.commitTransaction()` is called. Transactions do not affect updates to the frontend and incoming updates from the engine / other devices. When more than one reference to a subscription exists, the transaction affects all of them.
+
+Note that even in non-transaction mode, changes are batched and only committed after the current task finished. The changes are sent to the engine in a [microtask](https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide). You can end the current task and flush, for example, by awaiting a promise: `await Promise.resolve()`.
+
+Note that you can use the signal object of an orm subscription (e.g. `myOrmSubscription.signalObject`) in components too. For that, you need to use `useDeepSignal(signalObject)` from the package `@ng-org/alien-deepsignals/svelte|vue|react`. This can be useful to keep a connection open over the lifetime of a component and to avoid the loading time when creating new subscriptions.
+
+Example of using an OrmSubscription:
 
 ```typescript
 const dogSubscription = OrmSubscription.getOrCreate(DogShape, {
@@ -194,7 +235,7 @@ const dogSubscription = OrmSubscription.getOrCreate(DogShape, {
 });
 await dogSubscription.readyPromise;
 
-// If we used OrmDiscreteSubscription, the signalObject type would be array or object.
+// If we used OrmDiscreteSubscription, the signalObject type would be an array or object.
 const dogSet: DeepSignal<Set<Dog>> = dogSubscription.signalObject;
 
 dogs.add({
@@ -214,12 +255,26 @@ aDog.toy.add("bone");
 
 // Utility to find objects in sets:
 const sameDog = dogs.getBy(aDog["@graph"], aDog["@id"]);
-// sameSog === aDog.
+// sameDog === aDog.
 
 dogs.delete(aDog);
 ```
 
-Note that the graph CRDT supports sets only, the discrete CRDTs arrays only.
+Note that the RDF CRDT supports sets only, the discrete CRDTs arrays only.
+
+#### The DeepSignal<> type
+
+Data returned by the ORM is of type `DeepSignal<T>`. It behaves like plain objects of type `T` but with some extras. Under the hood, the object is proxied. The proxy tracks modifications and will immediately update the frontend and propagate to the engine.
+
+In your code however, you _do not have to to wrap your type definitions in `DeepSignal<>`_. Nevertheless, it can be instructive for TypeScript to show you the additional utilities that DeepSignal objects expose. Also, it might keep you aware that modifications you make to those objects are persisted and that they update the frontend.
+The utilities that DeepSignal objects include are:
+
+- For sets (with the RDF ORM):
+    - iterator helper methods (e.g. `map()`, `filter()`, `reduce()`, `any()`, ...)
+    - `first()` to get one element from the set -- useful if you know that there is only one.
+    - `getBy(graphNuri: string, subjectIri: string)`, to find objects by their graph NURI and subject IRI.
+    - **NOTE**: When assigning a set to `DeepSignal<Set>`, TypeScript will warn you. You can safely ignore this by writing (`parent.children = new Set() as DeepSignal<Set<any>>`). Internally, the set is automatically converted but this is not expressible in TypeScript.
+- For all objects: `__raw__` which gives you the non-proxied object without tracking value access and without triggering updates upon modifications. Tracking value access is used in the frontend so it knows on what changes to refresh. If you use `__raw__`, that won't work anymore.
 
 #### Graph ORM: Relationships
 
@@ -231,9 +286,10 @@ casey.friends.add(jackNuri);
 // When the child object is a nested object that you do not have in memory,
 // you can establish the link by adding an object that contains the `@id` property only.
 shoppingExpense.category.add({ "@id": "<Subject IRI of expense category>" });
-// Link objects by storing the target's `@id` NURI/IRI:
 
+// Link objects by storing the target's `@id` NURI/IRI:
 dog.owner = jackNuri;
+
 // Resolve the relationship
 const jack = people.find((p) => p["@id"] === dog.owner);
 ```

package/dist/connector/discrete/discreteOrmSubscriptionHandler.d.ts

@@ -25,12 +25,12 @@ export declare class DiscreteOrmSubscription {
     private refCount;
     /** When true, modifications from the signalObject are not processed. */
     private suspendDeepWatcher;
-    /** @readonly True, if a transaction is running. */
-    inTransaction: boolean;
-    /** Aggregation of patches to be sent when in transaction. */
-    pendingPatches: Patch[] | undefined;
+    /** True, if a transaction is running. */
+    private inTransaction_;
+    /** Aggregation of patches to be sent when in transaction. @ignore */
+    private pendingPatches;
     /** **Await to ensure that the subscription is established and the data arrived.** */
-    readyPromise: Promise<void>;
+    private readyPromise_;
     private closeOrmSubscription;
     /** Function to call once initial data has been applied. */
     private resolveReady;
@@ -124,6 +124,10 @@ export declare class DiscreteOrmSubscription {
      * ```
      */
     static getOrCreate: <T extends BaseType>(documentId: string) => DiscreteOrmSubscription;
+    /** True, if a transaction is running. */
+    get inTransaction(): boolean;
+    /** **Await to ensure that the subscription is established and the data arrived.** */
+    get readyPromise(): Promise<void>;
     /**
      * Stop the subscription.
      *

package/dist/connector/discrete/discreteOrmSubscriptionHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discreteOrmSubscriptionHandler.d.ts","sourceRoot":"","sources":["../../../src/connector/discrete/discreteOrmSubscriptionHandler.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAA4B,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAQrE,OAAO,KAAK,EACR,SAAS,EACT,UAAU,EAEb,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AASjD;;;;;;;;;GASG;AACH,qBAAa,uBAAuB;IAChC,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,SAAS,CAA8C;IAEtE,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,aAAa,CAEL;IAChB,OAAO,CAAC,mBAAmB,CAA2B;IACtD,qFAAqF;IACrF,OAAO,CAAC,cAAc,CAAqB;IAC3C,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAS;IACzB,wEAAwE;IACxE,OAAO,CAAC,kBAAkB,CAAU;IACpC,mDAAmD;IACnD,aAAa,EAAE,OAAO,CAAS;IAC/B,6DAA6D;IAC7D,cAAc,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC;IACpC,qFAAqF;IACrF,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,OAAO,CAAC,oBAAoB,CAAa;IACzC,2DAA2D;IAC3D,OAAO,CAAC,YAAY,CAAc;IAElC,OAAO;IA+BP;;;;;;;;OAQG;IACH,IAAW,YAAY,2DAEtB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6EG;IACH,OAAc,WAAW,GAAI,CAAC,SAAS,QAAQ,EAC3C,YAAY,MAAM,KACnB,uBAAuB,CAcxB;IAEF;;;;;;;;;OASG;IACI,KAAK,aASV;IAEF,wEAAwE;IACxE,OAAO,CAAC,oBAAoB,CAsB1B;IAEF,wEAAwE;IACxE,OAAO,CAAC,gBAAgB,CAStB;IAEF,OAAO,CAAC,qBAAqB,CAiB3B;IAEF,8CAA8C;IAC9C,OAAO,CAAC,eAAe,CAUrB;IAEF;;;;;;OAMG;IACI,gBAAgB,aAerB;IAEF;;;;OAIG;IACI,iBAAiB,sBAiCtB;CACL;AAED;;;;;;GAMG;AAEH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,CAO/D"}
+{"version":3,"file":"discreteOrmSubscriptionHandler.d.ts","sourceRoot":"","sources":["../../../src/connector/discrete/discreteOrmSubscriptionHandler.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAA4B,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAQrE,OAAO,KAAK,EACR,SAAS,EACT,UAAU,EAEb,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AASjD;;;;;;;;;GASG;AACH,qBAAa,uBAAuB;IAChC,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,SAAS,CAA8C;IAEtE,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,aAAa,CAEL;IAChB,OAAO,CAAC,mBAAmB,CAA2B;IACtD,qFAAqF;IACrF,OAAO,CAAC,cAAc,CAAqB;IAC3C,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAS;IACzB,wEAAwE;IACxE,OAAO,CAAC,kBAAkB,CAAU;IACpC,yCAAyC;IACzC,OAAO,CAAC,cAAc,CAAkB;IACxC,qEAAqE;IACrE,OAAO,CAAC,cAAc,CAAsB;IAC5C,qFAAqF;IACrF,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,oBAAoB,CAAa;IACzC,2DAA2D;IAC3D,OAAO,CAAC,YAAY,CAAc;IAElC,OAAO;IA+BP;;;;;;;;OAQG;IACH,IAAW,YAAY,2DAEtB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6EG;IACH,OAAc,WAAW,GAAI,CAAC,SAAS,QAAQ,EAC3C,YAAY,MAAM,KACnB,uBAAuB,CAcxB;IAEF,yCAAyC;IACzC,IAAI,aAAa,YAEhB;IACD,qFAAqF;IACrF,IAAI,YAAY,kBAEf;IAED;;;;;;;;;OASG;IACI,KAAK,aASV;IAEF,wEAAwE;IACxE,OAAO,CAAC,oBAAoB,CAsB1B;IAEF,wEAAwE;IACxE,OAAO,CAAC,gBAAgB,CAStB;IAEF,OAAO,CAAC,qBAAqB,CAiB3B;IAEF,8CAA8C;IAC9C,OAAO,CAAC,eAAe,CAUrB;IAEF;;;;;;OAMG;IACI,gBAAgB,aAerB;IAEF;;;;OAIG;IACI,iBAAiB,sBAiCtB;CACL;AAED;;;;;;GAMG;AAEH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,CAO/D"}

package/dist/connector/discrete/discreteOrmSubscriptionHandler.js

@@ -39,12 +39,12 @@ export class DiscreteOrmSubscription {
     refCount;
     /** When true, modifications from the signalObject are not processed. */
     suspendDeepWatcher;
-    /** @readonly True, if a transaction is running. */
-    inTransaction = false;
-    /** Aggregation of patches to be sent when in transaction. */
+    /** True, if a transaction is running. */
+    inTransaction_ = false;
+    /** Aggregation of patches to be sent when in transaction. @ignore */
     pendingPatches;
     /** **Await to ensure that the subscription is established and the data arrived.** */
-    readyPromise;
+    readyPromise_;
     closeOrmSubscription;
     /** Function to call once initial data has been applied. */
     resolveReady;
@@ -60,7 +60,7 @@ export class DiscreteOrmSubscription {
         this.closeOrmSubscription = () => { };
         this.suspendDeepWatcher = false;
         // Initialize per-entry readiness promise that resolves in setUpConnection
-        this.readyPromise = new Promise((resolve) => {
+        this.readyPromise_ = new Promise((resolve) => {
             this.resolveReady = resolve;
         });
         ngSession.then(async ({ ng, session }) => {
@@ -177,6 +177,14 @@ export class DiscreteOrmSubscription {
             return newConnection;
         }
     };
+    /** True, if a transaction is running. */
+    get inTransaction() {
+        return this.inTransaction_;
+    }
+    /** **Await to ensure that the subscription is established and the data arrived.** */
+    get readyPromise() {
+        return this.readyPromise_;
+    }
     /**
      * Stop the subscription.
      *
@@ -203,13 +211,13 @@ export class DiscreteOrmSubscription {
             return;
         const ormPatches = deepPatchesToWasm(patches);
         // If in transaction, collect patches immediately (no await before).
-        if (this.inTransaction) {
+        if (this.inTransaction_) {
             this.pendingPatches?.push(...ormPatches);
             return;
         }
         // Wait for session and subscription to be initialized.
         const { ng, session } = await ngSession;
-        await this.readyPromise;
+        await this.readyPromise_;
         ng.discrete_orm_update(this.subscriptionId, ormPatches, session.session_id);
     };
     /** Handle messages coming from the engine (initial data or patches). */
@@ -255,9 +263,9 @@ export class DiscreteOrmSubscription {
      * Modifications keep being rendered instantly.
      */
     beginTransaction = () => {
-        this.inTransaction = true;
+        this.inTransaction_ = true;
         this.pendingPatches = [];
-        this.readyPromise.then(() => {
+        this.readyPromise_.then(() => {
             // Use a listener that immediately triggers on object modifications.
             // We don't need the deep-signal's batching (through microtasks) here.
             this.stopSignalListening?.();
@@ -271,12 +279,12 @@ export class DiscreteOrmSubscription {
      * @throws if no transaction is open.
      */
     commitTransaction = async () => {
-        if (!this.inTransaction) {
+        if (!this.inTransaction_) {
             throw new Error("No transaction is open. Call `beginTransaction` first.");
         }
         const { ng, session } = await ngSession;
-        await this.readyPromise;
-        this.inTransaction = false;
+        await this.readyPromise_;
+        this.inTransaction_ = false;
         if (this.pendingPatches?.length == 0) {
             // Nothing to send to the backend.
         }

package/dist/connector/getObjects.d.ts

@@ -4,8 +4,8 @@ import { Scope } from "../types.ts";
  * Utility for retrieving objects once without establishing a two-way subscription.
  *
  * @param shapeType The shape type of the objects to be retrieved.
- * @param scope The scope of the objects to be retrieved.
+ * @param scope The scope of the objects to be retrieved as Scope object or as graph NURI string.
  * @returns A set of all objects matching the shape and scope
  */
-export declare function getObjects<T extends BaseType>(shapeType: ShapeType<T>, scope?: Scope): Promise<import("@ng-org/alien-deepsignals").DeepSignalSet<T>>;
+export declare function getObjects<T extends BaseType>(shapeType: ShapeType<T>, scope: Scope | string): Promise<import("@ng-org/alien-deepsignals").DeepSignalSet<T>>;
 //# sourceMappingURL=getObjects.d.ts.map

package/dist/connector/getObjects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getObjects.d.ts","sourceRoot":"","sources":["../../src/connector/getObjects.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAC/C,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EACvB,KAAK,GAAE,KAAU,iEAUpB"}
+{"version":3,"file":"getObjects.d.ts","sourceRoot":"","sources":["../../src/connector/getObjects.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAkB,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAC/C,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,KAAK,GAAG,MAAM,iEAaxB"}

package/dist/connector/getObjects.js

@@ -8,16 +8,17 @@
 // according to those terms.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 import { OrmSubscription } from "./ormSubscriptionHandler.js";
+import { normalizeScope } from "../types.js";
 import { deepClone } from "./utils.js";
 /**
  * Utility for retrieving objects once without establishing a two-way subscription.
  *
  * @param shapeType The shape type of the objects to be retrieved.
- * @param scope The scope of the objects to be retrieved.
+ * @param scope The scope of the objects to be retrieved as Scope object or as graph NURI string.
  * @returns A set of all objects matching the shape and scope
  */
-export async function getObjects(shapeType, scope = {}) {
-    const connection = OrmSubscription.getOrCreate(shapeType, scope);
+export async function getObjects(shapeType, scope) {
+    const connection = OrmSubscription.getOrCreate(shapeType, normalizeScope(scope));
     await connection.readyPromise;
     setTimeout(() => {
         connection.close();

package/dist/connector/initNg.d.ts

@@ -1,21 +1,13 @@
-import * as NG from "@ng-org/lib-wasm";
-export type Session = {
-    session_id: string | number;
-    protected_store_id: string;
-    private_store_id: string;
-    public_store_id: string;
-    ng: typeof NG;
-    [key: string]: unknown;
-};
+import type { Session, NG } from "@ng-org/web";
 /** Resolves to the NG session and the ng implementation. */
 export declare const ngSession: Promise<{
-    ng: typeof NG;
+    ng: NG;
     session: Session;
 }>;
 /**
  * Initialize the ORM by passing the ng implementation and session.
  *
- * **This is the first thing you need to to before using the ORM.**
+ * **This is the first thing you need to do before using the ORM.**
  *
  * @param ngImpl The NextGraph API, e.g. exported from `@ng-org/web`.
  * @param session The established NextGraph session.
@@ -41,5 +33,5 @@ export declare const ngSession: Promise<{
  * ```
  *
  */
-export declare function initNgSignals(ngImpl: typeof NG, session: Session): void;
+export declare function initNgSignals(ngImpl: NG, session: Session): void;
 //# sourceMappingURL=initNg.d.ts.map

package/dist/connector/initNg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initNg.d.ts","sourceRoot":"","sources":["../../src/connector/initNg.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEvC,MAAM,MAAM,OAAO,GAAG;IAClB,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,EAAE,EAAE,OAAO,EAAE,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAIF,4DAA4D;AAC5D,eAAO,MAAM,SAAS;QAAqB,OAAO,EAAE;aAAW,OAAO;EAIrE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,QAEhE"}
+{"version":3,"file":"initNg.d.ts","sourceRoot":"","sources":["../../src/connector/initNg.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAI/C,4DAA4D;AAC5D,eAAO,MAAM,SAAS;QAAqB,EAAE;aAAW,OAAO;EAI9D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,QAEzD"}

package/dist/connector/initNg.js

@@ -15,7 +15,7 @@ export const ngSession = new Promise((resolve) => {
 /**
  * Initialize the ORM by passing the ng implementation and session.
  *
- * **This is the first thing you need to to before using the ORM.**
+ * **This is the first thing you need to do before using the ORM.**
  *
  * @param ngImpl The NextGraph API, e.g. exported from `@ng-org/web`.
  * @param session The established NextGraph session.

package/dist/connector/insertObject.d.ts

@@ -1,6 +1,7 @@
 import { BaseType, ShapeType } from "@ng-org/shex-orm";
 /**
- * Utility for adding ORM-typed objects to the database without the need for subscribing to documents.
+ * Utility for adding ORM-typed objects to the database without
+ * the need for subscribing to documents using an {@link OrmSubscription}.
  *
  * @param shapeType The shape type of the objects to be inserted.
  * @param object The object to be inserted.

package/dist/connector/insertObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insertObject.d.ts","sourceRoot":"","sources":["../../src/connector/insertObject.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGvD;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,QAAQ,EACjD,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,iBASZ"}
+{"version":3,"file":"insertObject.d.ts","sourceRoot":"","sources":["../../src/connector/insertObject.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGvD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,QAAQ,EACjD,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,iBASZ"}

package/dist/connector/insertObject.js

@@ -9,7 +9,8 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 import { OrmSubscription } from "./ormSubscriptionHandler.js";
 /**
- * Utility for adding ORM-typed objects to the database without the need for subscribing to documents.
+ * Utility for adding ORM-typed objects to the database without
+ * the need for subscribing to documents using an {@link OrmSubscription}.
  *
  * @param shapeType The shape type of the objects to be inserted.
  * @param object The object to be inserted.

package/dist/connector/ormSubscriptionHandler.d.ts

@@ -1,5 +1,4 @@
 import { type Scope } from "../types.ts";
-import { Patch } from "./applyPatches.ts";
 import type { DeepSignalSet } from "@ng-org/alien-deepsignals";
 import type { ShapeType, BaseType } from "@ng-org/shex-orm";
 /**
@@ -41,13 +40,13 @@ export declare class OrmSubscription<T extends BaseType> {
     /** Identifier as a combination of shape type and scope. Prevents duplications. */
     private identifier;
     /** When true, modifications from the signalObject are not processed. */
-    suspendDeepWatcher: boolean;
+    private suspendDeepWatcher;
     /** True, if a transaction is running. */
-    inTransaction: boolean;
-    /** Aggregation of patches to be sent when in transaction. */
-    pendingPatches: Patch[] | undefined;
+    private inTransaction_;
+    /** Aggregation of patches to be sent when in transaction. @ignore */
+    private pendingPatches;
     /** **Await to ensure that the subscription is established and the data arrived.** */
-    readyPromise: Promise<void>;
+    private readyPromise_;
     private closeOrmSubscription;
     /** Function to call once initial data has been applied. */
     private resolveReady;
@@ -130,6 +129,10 @@ export declare class OrmSubscription<T extends BaseType> {
      * ```
      */
     static getOrCreate: <T_1 extends BaseType>(shapeType: ShapeType<T_1>, scope: Scope) => OrmSubscription<T_1>;
+    /** True, if a transaction is running. */
+    get inTransaction(): boolean;
+    /** **Await to ensure that the subscription is established and the data arrived.** */
+    get readyPromise(): Promise<void>;
     /**
      * Stop the subscription.
      *

package/dist/connector/ormSubscriptionHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ormSubscriptionHandler.d.ts","sourceRoot":"","sources":["../../src/connector/ormSubscriptionHandler.ts"],"names":[],"mappings":"AAUA,OAAO,EAAkB,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAA4B,KAAK,EAAE,MAAM,mBAAmB,CAAC;AASpE,OAAO,KAAK,EAER,aAAa,EAEhB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAU5D;;;;;;;;;GASG;AACH,qBAAa,eAAe,CAAC,CAAC,SAAS,QAAQ;IAC3C,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,SAAS,CAA2C;IAEnE,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACjC,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACxC,OAAO,CAAC,mBAAmB,CAAa;IACxC,qFAAqF;IACrF,OAAO,CAAC,cAAc,CAAqB;IAC3C,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAS;IACzB,kFAAkF;IAClF,OAAO,CAAC,UAAU,CAAS;IAC3B,wEAAwE;IACxE,kBAAkB,EAAE,OAAO,CAAC;IAC5B,yCAAyC;IACzC,aAAa,EAAE,OAAO,CAAS;IAC/B,6DAA6D;IAC7D,cAAc,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC;IACpC,qFAAqF;IACrF,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,OAAO,CAAC,oBAAoB,CAAa;IACzC,2DAA2D;IAC3D,OAAO,CAAC,YAAY,CAAc;IAGlC,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAUrB;IAEf,OAAO;IAqDP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EG;IACH,OAAc,WAAW,GAAI,GAAC,SAAS,QAAQ,EAC3C,WAAW,SAAS,CAAC,GAAC,CAAC,EACvB,OAAO,KAAK,KACb,eAAe,CAAC,GAAC,CAAC,CAkBnB;IAEF;;;;;;;;;OASG;IACI,KAAK,aAYV;IAEF,wEAAwE;IACxE,OAAO,CAAC,oBAAoB,CAoB1B;IAEF,wEAAwE;IACxE,OAAO,CAAC,gBAAgB,CAStB;IAEF,OAAO,CAAC,qBAAqB,CAuB3B;IAEF,8CAA8C;IAC9C,OAAO,CAAC,eAAe,CAOrB;IAEF,gFAAgF;IAChF,OAAO,CAAC,yBAAyB,CAgD/B;IAEF;;;;;;OAMG;IACI,gBAAgB,aAarB;IAEF;;;OAGG;IACI,iBAAiB,sBAkCtB;CACL"}
+{"version":3,"file":"ormSubscriptionHandler.d.ts","sourceRoot":"","sources":["../../src/connector/ormSubscriptionHandler.ts"],"names":[],"mappings":"AAUA,OAAO,EAAkB,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAUzD,OAAO,KAAK,EAER,aAAa,EAEhB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAU5D;;;;;;;;;GASG;AACH,qBAAa,eAAe,CAAC,CAAC,SAAS,QAAQ;IAC3C,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,SAAS,CAA2C;IAEnE,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACjC,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACxC,OAAO,CAAC,mBAAmB,CAAa;IACxC,qFAAqF;IACrF,OAAO,CAAC,cAAc,CAAqB;IAC3C,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAS;IACzB,kFAAkF;IAClF,OAAO,CAAC,UAAU,CAAS;IAC3B,wEAAwE;IACxE,OAAO,CAAC,kBAAkB,CAAU;IACpC,yCAAyC;IACzC,OAAO,CAAC,cAAc,CAAkB;IACxC,qEAAqE;IACrE,OAAO,CAAC,cAAc,CAAsB;IAC5C,qFAAqF;IACrF,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,oBAAoB,CAAa;IACzC,2DAA2D;IAC3D,OAAO,CAAC,YAAY,CAAc;IAGlC,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAUrB;IAEf,OAAO;IAqDP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EG;IACH,OAAc,WAAW,GAAI,GAAC,SAAS,QAAQ,EAC3C,WAAW,SAAS,CAAC,GAAC,CAAC,EACvB,OAAO,KAAK,KACb,eAAe,CAAC,GAAC,CAAC,CAkBnB;IAEF,yCAAyC;IACzC,IAAI,aAAa,YAEhB;IACD,qFAAqF;IACrF,IAAI,YAAY,kBAEf;IAED;;;;;;;;;OASG;IACI,KAAK,aAYV;IAEF,wEAAwE;IACxE,OAAO,CAAC,oBAAoB,CAoB1B;IAEF,wEAAwE;IACxE,OAAO,CAAC,gBAAgB,CAStB;IAEF,OAAO,CAAC,qBAAqB,CAuB3B;IAEF,8CAA8C;IAC9C,OAAO,CAAC,eAAe,CAOrB;IAEF,gFAAgF;IAChF,OAAO,CAAC,yBAAyB,CAgD/B;IAEF;;;;;;OAMG;IACI,gBAAgB,aAarB;IAEF;;;OAGG;IACI,iBAAiB,sBAkCtB;CACL"}

package/dist/connector/ormSubscriptionHandler.js

@@ -59,11 +59,11 @@ export class OrmSubscription {
     /** When true, modifications from the signalObject are not processed. */
     suspendDeepWatcher;
     /** True, if a transaction is running. */
-    inTransaction = false;
-    /** Aggregation of patches to be sent when in transaction. */
+    inTransaction_ = false;
+    /** Aggregation of patches to be sent when in transaction. @ignore */
     pendingPatches;
     /** **Await to ensure that the subscription is established and the data arrived.** */
-    readyPromise;
+    readyPromise_;
     closeOrmSubscription;
     /** Function to call once initial data has been applied. */
     resolveReady;
@@ -102,7 +102,7 @@ export class OrmSubscription {
         const { stopListening } = watchDeepSignal(this.signalObject, this.onSignalObjectUpdate);
         this.stopSignalListening = stopListening;
         // Set promise to be resolved when data arrived from engine.
-        this.readyPromise = new Promise((resolve) => {
+        this.readyPromise_ = new Promise((resolve) => {
             this.resolveReady = resolve;
         });
         ngSession.then(async ({ ng, session }) => {
@@ -208,6 +208,14 @@ export class OrmSubscription {
             return newConnection;
         }
     };
+    /** True, if a transaction is running. */
+    get inTransaction() {
+        return this.inTransaction_;
+    }
+    /** **Await to ensure that the subscription is established and the data arrived.** */
+    get readyPromise() {
+        return this.readyPromise_;
+    }
     /**
      * Stop the subscription.
      *
@@ -235,13 +243,13 @@ export class OrmSubscription {
             return;
         const ormPatches = deepPatchesToWasm(patches);
         // If in transaction, collect patches immediately (no await before).
-        if (this.inTransaction) {
+        if (this.inTransaction_) {
             this.pendingPatches?.push(...ormPatches);
             return;
         }
         // Wait for session and subscription to be initialized.
         const { ng, session } = await ngSession;
-        await this.readyPromise;
+        await this.readyPromise_;
         ng.graph_orm_update(this.subscriptionId, ormPatches, session.session_id);
     };
     /** Handle messages coming from the engine (initial data or patches). */
@@ -335,7 +343,7 @@ export class OrmSubscription {
      * Modifications keep being rendered.
      */
     beginTransaction = () => {
-        this.inTransaction = true;
+        this.inTransaction_ = true;
         this.pendingPatches = [];
         // Use a listener that immediately triggers on object modifications.
         // We don't need the deep-signal's batching (through microtasks) here.
@@ -348,12 +356,12 @@ export class OrmSubscription {
      * (started with `beginTransaction`) to the database.
      */
     commitTransaction = async () => {
-        if (!this.inTransaction) {
+        if (!this.inTransaction_) {
             throw new Error("No transaction is open. Call `beginTransaction` first.");
         }
         const { ng, session } = await ngSession;
-        await this.readyPromise;
-        this.inTransaction = false;
+        await this.readyPromise_;
+        this.inTransaction_ = false;
         if (this.pendingPatches?.length == 0) {
             // Nothing to send to the engine.
         }

package/dist/core.d.ts

@@ -0,0 +1,10 @@
+import { OrmSubscription } from "./connector/ormSubscriptionHandler.ts";
+import { DiscreteOrmSubscription } from "./connector/discrete/discreteOrmSubscriptionHandler.ts";
+import { initNgSignals, ngSession } from "./connector/initNg.ts";
+import { insertObject } from "./connector/insertObject.ts";
+import { getObjects } from "./connector/getObjects.ts";
+export * from "./types.ts";
+export type { DeepSignal, DeepSignalObject, DeepSignalSet, } from "@ng-org/alien-deepsignals";
+export { getRaw, watch, effect } from "@ng-org/alien-deepsignals";
+export { initNgSignals as initNg, ngSession, OrmSubscription, DiscreteOrmSubscription, insertObject, getObjects, };
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wDAAwD,CAAC;AACjG,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD,cAAc,YAAY,CAAC;AAE3B,YAAY,EACR,UAAU,EACV,gBAAgB,EAChB,aAAa,GAChB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,EACH,aAAa,IAAI,MAAM,EACvB,SAAS,EACT,eAAe,EACf,uBAAuB,EACvB,YAAY,EACZ,UAAU,GACb,CAAC"}

package/dist/core.js

@@ -0,0 +1,17 @@
+// Copyright (c) 2026 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+import { OrmSubscription } from "./connector/ormSubscriptionHandler.js";
+import { DiscreteOrmSubscription } from "./connector/discrete/discreteOrmSubscriptionHandler.js";
+import { initNgSignals, ngSession } from "./connector/initNg.js";
+import { insertObject } from "./connector/insertObject.js";
+import { getObjects } from "./connector/getObjects.js";
+export * from "./types.js";
+export { getRaw, watch, effect } from "@ng-org/alien-deepsignals";
+export { initNgSignals as initNg, ngSession, OrmSubscription, DiscreteOrmSubscription, insertObject, getObjects, };

package/dist/frontendAdapters/react/useDiscrete.d.ts

@@ -98,7 +98,7 @@ import { DiscreteRoot } from "../../types.ts";
  * }
  * ```
  */
-export declare function useDiscrete<T extends DiscreteRoot = DiscreteRoot>(documentId: string | undefined): {
+export declare function useDiscrete<T = DiscreteRoot>(documentId: string | undefined): {
     doc: DeepSignal<T> | undefined;
 };
 //# sourceMappingURL=useDiscrete.d.ts.map

package/dist/frontendAdapters/react/useDiscrete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDiscrete.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/react/useDiscrete.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGG;AAEH,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAC7D,UAAU,EAAE,MAAM,GAAG,SAAS;;EAsDjC"}
+{"version":3,"file":"useDiscrete.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/react/useDiscrete.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGG;AAEH,wBAAgB,WAAW,CAAC,CAAC,GAAG,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;;EAqD3E"}

package/dist/frontendAdapters/svelte/useDiscrete.svelte.d.ts

@@ -88,7 +88,7 @@ import { DeepSignal } from "@ng-org/alien-deepsignals";
  * </div>
  * ```
  */
-export declare function useDiscrete<T extends DiscreteRoot = DiscreteRoot>(documentIdOrPromise: string | Promise<string> | undefined): {
+export declare function useDiscrete<T = DiscreteRoot>(documentIdOrPromise: string | Promise<string> | undefined): {
     doc: DeepSignal<T | undefined>;
 };
 //# sourceMappingURL=useDiscrete.svelte.d.ts.map

package/dist/frontendAdapters/svelte/useDiscrete.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDiscrete.svelte.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte/useDiscrete.svelte.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAC7D,mBAAmB,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GAC1D;IACC,GAAG,EAAE,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CAClC,CAqCA"}
+{"version":3,"file":"useDiscrete.svelte.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte/useDiscrete.svelte.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,YAAY,EACxC,mBAAmB,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GAC1D;IACC,GAAG,EAAE,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CAClC,CAqCA"}

package/dist/frontendAdapters/svelte4/index.d.ts

@@ -1,5 +1,5 @@
 import useShape from "./useShape.svelte.ts";
 import { useDiscrete } from "./useDiscrete.svelte.ts";
-import { UseDeepSignalResult } from "./useShape.svelte.ts";
-export { useShape, useDiscrete, type UseDeepSignalResult };
+import type { UseShapeStoreResult } from "./useShape.svelte.ts";
+export { useShape, useDiscrete, type UseShapeStoreResult };
 //# sourceMappingURL=index.d.ts.map

package/dist/frontendAdapters/svelte4/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte4/index.ts"],"names":[],"mappings":"AAUA,OAAO,QAAQ,MAAM,sBAAsB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte4/index.ts"],"names":[],"mappings":"AAUA,OAAO,QAAQ,MAAM,sBAAsB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,CAAC"}

package/dist/frontendAdapters/svelte4/useDiscrete.svelte.d.ts

@@ -80,5 +80,7 @@ import { DiscreteRoot } from "../../types.ts";
  * ```
  *
  */
-export declare function useDiscrete<T extends DiscreteRoot = DiscreteRoot>(documentIdOrPromise: string | Promise<string> | undefined): UseDeepSignalResult<T | undefined>;
+export declare function useDiscrete<T = DiscreteRoot>(documentIdOrPromise: string | Promise<string> | undefined): {
+    doc: UseDeepSignalResult<T | undefined>;
+};
 //# sourceMappingURL=useDiscrete.svelte.d.ts.map

package/dist/frontendAdapters/svelte4/useDiscrete.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDiscrete.svelte.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte4/useDiscrete.svelte.ts"],"names":[],"mappings":"AAWA,OAAO,EAEH,mBAAmB,EACtB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAC7D,mBAAmB,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GAC1D,mBAAmB,CAAC,CAAC,GAAG,SAAS,CAAC,CAkCpC"}
+{"version":3,"file":"useDiscrete.svelte.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte4/useDiscrete.svelte.ts"],"names":[],"mappings":"AAWA,OAAO,EAEH,mBAAmB,EACtB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,YAAY,EACxC,mBAAmB,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GAC1D;IAAE,GAAG,EAAE,mBAAmB,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;CAAE,CAkC7C"}

package/dist/frontendAdapters/svelte4/useDiscrete.svelte.js

@@ -122,5 +122,5 @@ export function useDiscrete(documentIdOrPromise) {
             connection.close();
         }
     });
-    return useDeepSignal(objectPromise);
+    return { doc: useDeepSignal(objectPromise) };
 }

package/dist/frontendAdapters/svelte4/useShape.svelte.d.ts

@@ -1,9 +1,8 @@
 import { type Scope } from "../../types.ts";
 import type { BaseType, ShapeType } from "@ng-org/shex-orm";
 import { type UseDeepSignalResult } from "@ng-org/alien-deepsignals/svelte4";
-export type { UseDeepSignalResult } from "@ng-org/alien-deepsignals/svelte4";
-/** Extended result including the originating root signal wrapper from shape logic. */
-export interface UseShapeRuneResult<T extends object> extends UseDeepSignalResult<T> {
+/** Extended result including the originating root signal wrapper from shape logic. @ignore*/
+export interface UseShapeStoreResult<T = object> extends UseDeepSignalResult<T> {
     root: any;
 }
 /**
@@ -72,6 +71,6 @@ export interface UseShapeRuneResult<T extends object> extends UseDeepSignalResul
  * </div>
  * ```
  */
-export declare function useShape<T extends BaseType>(shape: ShapeType<T>, scope: Scope | string | undefined): UseShapeRuneResult<Set<T>>;
+export declare function useShape<T extends BaseType>(shape: ShapeType<T>, scope: Scope | string | undefined): UseShapeStoreResult<Set<T>>;
 export default useShape;
 //# sourceMappingURL=useShape.svelte.d.ts.map

package/dist/frontendAdapters/svelte4/useShape.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useShape.svelte.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte4/useShape.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EAAkB,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5D,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,mCAAmC,CAAC;AAK3C,YAAY,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,sFAAsF;AACtF,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAChD,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IAC9B,IAAI,EAAE,GAAG,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EACvC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,GAClC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAe5B;AAED,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"useShape.svelte.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/svelte4/useShape.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EAAkB,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5D,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,mCAAmC,CAAC;AAK3C,6FAA6F;AAC7F,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,MAAM,CAC3C,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IAC9B,IAAI,EAAE,GAAG,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EACvC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,GAClC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAe7B;AAED,eAAe,QAAQ,CAAC"}

package/dist/frontendAdapters/vue/useDiscrete.d.ts

@@ -93,7 +93,7 @@ import { DiscreteRoot } from "../../types.ts";
  * </template>
  * ```
  */
-export declare function useDiscrete<T extends DiscreteRoot = DiscreteRoot>(documentId: MaybeRefOrGetter<string | undefined>): ToRefs<{
+export declare function useDiscrete<T = DiscreteRoot>(documentId: MaybeRefOrGetter<string | undefined>): ToRefs<{
     doc: T;
 }>;
 //# sourceMappingURL=useDiscrete.d.ts.map

package/dist/frontendAdapters/vue/useDiscrete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDiscrete.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/vue/useDiscrete.ts"],"names":[],"mappings":"AAUA,OAAO,EAEH,gBAAgB,EAGhB,MAAM,EAIT,MAAM,KAAK,CAAC;AAGb,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4FG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAC7D,UAAU,EAAE,gBAAgB,CAAC,MAAM,GAAG,SAAS,CAAC,GAoB1B,MAAM,CAAC;IAAE,GAAG,EAAE,CAAC,CAAA;CAAE,CAAC,CAC3C"}
+{"version":3,"file":"useDiscrete.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/vue/useDiscrete.ts"],"names":[],"mappings":"AAUA,OAAO,EAEH,gBAAgB,EAGhB,MAAM,EAIT,MAAM,KAAK,CAAC;AAGb,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4FG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,YAAY,EACxC,UAAU,EAAE,gBAAgB,CAAC,MAAM,GAAG,SAAS,CAAC,GAoB1B,MAAM,CAAC;IAAE,GAAG,EAAE,CAAC,CAAA;CAAE,CAAC,CAC3C"}

package/dist/index.d.ts

@@ -1,15 +1,7 @@
-import { OrmSubscription } from "./connector/ormSubscriptionHandler.ts";
-import { DiscreteOrmSubscription } from "./connector/discrete/discreteOrmSubscriptionHandler.ts";
 import { useShape as svelteUseShape, useDiscrete as svelteUseDiscrete } from "./frontendAdapters/svelte/index.ts";
-import { useShape as svelte4UseShape, useDiscrete as svelte4UseDiscrete } from "./frontendAdapters/svelte4/index.ts";
+import { useShape as svelte4UseShape, useDiscrete as svelte4UseDiscrete, type UseShapeStoreResult as Svelte4UseShapeStoreResult } from "./frontendAdapters/svelte4/index.ts";
 import { useShape as reactUseShape, useDiscrete as reactUseDiscrete } from "./frontendAdapters/react/index.ts";
 import { useShape as vueUseShape, useDiscrete as vueUseDiscrete } from "./frontendAdapters/vue/index.ts";
-import { initNgSignals, ngSession } from "./connector/initNg.ts";
-import { insertObject } from "./connector/insertObject.ts";
-import { getObjects } from "./connector/getObjects.ts";
-export * from "./connector/applyPatches.ts";
-export * from "./types.ts";
-export type { DeepSignal, DeepSignalObject, DeepSignalSet, } from "@ng-org/alien-deepsignals";
-export { getRaw, watch, effect } from "@ng-org/alien-deepsignals";
-export { initNgSignals as initNg, ngSession, OrmSubscription as OrmSubscription, DiscreteOrmSubscription, svelteUseShape, svelteUseDiscrete, svelte4UseShape, svelte4UseDiscrete, reactUseShape, reactUseDiscrete, vueUseShape, vueUseDiscrete, insertObject, getObjects, };
+export * from "./core.ts";
+export { svelteUseShape, svelteUseDiscrete, svelte4UseShape, svelte4UseDiscrete, Svelte4UseShapeStoreResult, reactUseShape, reactUseDiscrete, vueUseShape, vueUseDiscrete, };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wDAAwD,CAAC;AACjG,OAAO,EACH,QAAQ,IAAI,cAAc,EAC1B,WAAW,IAAI,iBAAiB,EACnC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACH,QAAQ,IAAI,eAAe,EAC3B,WAAW,IAAI,kBAAkB,EACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACH,QAAQ,IAAI,aAAa,EACzB,WAAW,IAAI,gBAAgB,EAClC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACH,QAAQ,IAAI,WAAW,EACvB,WAAW,IAAI,cAAc,EAChC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,YAAY,CAAC;AAE3B,YAAY,EACR,UAAU,EACV,gBAAgB,EAChB,aAAa,GAChB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,EACH,aAAa,IAAI,MAAM,EACvB,SAAS,EACT,eAAe,IAAI,eAAe,EAClC,uBAAuB,EACvB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,YAAY,EACZ,UAAU,GACb,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EACH,QAAQ,IAAI,cAAc,EAC1B,WAAW,IAAI,iBAAiB,EACnC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACH,QAAQ,IAAI,eAAe,EAC3B,WAAW,IAAI,kBAAkB,EACjC,KAAK,mBAAmB,IAAI,0BAA0B,EACzD,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACH,QAAQ,IAAI,aAAa,EACzB,WAAW,IAAI,gBAAgB,EAClC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACH,QAAQ,IAAI,WAAW,EACvB,WAAW,IAAI,cAAc,EAChC,MAAM,iCAAiC,CAAC;AAEzC,cAAc,WAAW,CAAC;AAE1B,OAAO,EACH,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,0BAA0B,EAC1B,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,cAAc,GACjB,CAAC"}

package/dist/index.js

@@ -7,16 +7,9 @@
 // notice may not be copied, modified, or distributed except
 // according to those terms.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
-import { OrmSubscription } from "./connector/ormSubscriptionHandler.js";
-import { DiscreteOrmSubscription } from "./connector/discrete/discreteOrmSubscriptionHandler.js";
 import { useShape as svelteUseShape, useDiscrete as svelteUseDiscrete, } from "./frontendAdapters/svelte/index.js";
 import { useShape as svelte4UseShape, useDiscrete as svelte4UseDiscrete, } from "./frontendAdapters/svelte4/index.js";
 import { useShape as reactUseShape, useDiscrete as reactUseDiscrete, } from "./frontendAdapters/react/index.js";
 import { useShape as vueUseShape, useDiscrete as vueUseDiscrete, } from "./frontendAdapters/vue/index.js";
-import { initNgSignals, ngSession } from "./connector/initNg.js";
-import { insertObject } from "./connector/insertObject.js";
-import { getObjects } from "./connector/getObjects.js";
-export * from "./connector/applyPatches.js";
-export * from "./types.js";
-export { getRaw, watch, effect } from "@ng-org/alien-deepsignals";
-export { initNgSignals as initNg, ngSession, OrmSubscription as OrmSubscription, DiscreteOrmSubscription, svelteUseShape, svelteUseDiscrete, svelte4UseShape, svelte4UseDiscrete, reactUseShape, reactUseDiscrete, vueUseShape, vueUseDiscrete, insertObject, getObjects, };
+export * from "./core.js";
+export { svelteUseShape, svelteUseDiscrete, svelte4UseShape, svelte4UseDiscrete, reactUseShape, reactUseDiscrete, vueUseShape, vueUseDiscrete, };

package/dist/types.d.ts

@@ -33,7 +33,7 @@ export declare const normalizeScope: (scope?: Scope | string | undefined) => {
     graphs: string[];
     subjects: string[];
 };
-/** An allowed array in the CRDT. */
+/** An allowed array in the CRDT. @ignore */
 export interface DiscreteArray extends Array<DiscreteType> {
 }
 /** An allowed object in the CRDT. */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,KAAK,GAAG;IAChB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,QAAO,KAAK,GAAG,MAAM,GAAG,SAAc;;;CASpE,CAAC;AAEF,oCAAoC;AACpC,MAAM,WAAW,aAAc,SAAQ,KAAK,CAAC,YAAY,CAAC;CAAG;AAE7D,qCAAqC;AACrC,MAAM,WAAW,cAAc;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAC;CAC/B;AACD,mCAAmC;AACnC,MAAM,MAAM,YAAY,GAClB,aAAa,GACb,cAAc,GACd,MAAM,GACN,MAAM,GACN,OAAO,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC1B,aAAa,GACb,MAAM,GACN,MAAM,GACN,OAAO,GACP,CAAC,cAAc,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAClD,EAAE,CAAC;AAEJ;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,CAAC,GAAG,EAAE,MAAM,GACN,cAAc,GACd,MAAM,GACN,MAAM,GACN,OAAO,GACP,iBAAiB,CAAC;CAC3B;AAED,uEAAuE;AACvE,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAElE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,KAAK,GAAG;IAChB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,QAAO,KAAK,GAAG,MAAM,GAAG,SAAc;;;CASpE,CAAC;AAEF,4CAA4C;AAC5C,MAAM,WAAW,aAAc,SAAQ,KAAK,CAAC,YAAY,CAAC;CAAG;AAE7D,qCAAqC;AACrC,MAAM,WAAW,cAAc;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAC;CAC/B;AACD,mCAAmC;AACnC,MAAM,MAAM,YAAY,GAClB,aAAa,GACb,cAAc,GACd,MAAM,GACN,MAAM,GACN,OAAO,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC1B,aAAa,GACb,MAAM,GACN,MAAM,GACN,OAAO,GACP,CAAC,cAAc,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAClD,EAAE,CAAC;AAEJ;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,CAAC,GAAG,EAAE,MAAM,GACN,cAAc,GACd,MAAM,GACN,MAAM,GACN,OAAO,GACP,iBAAiB,CAAC;CAC3B;AAED,uEAAuE;AACvE,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAElE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC"}

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@ng-org/orm",
-  "version": "0.1.2-alpha.10",
+  "version": "0.1.2-alpha.12",
   "private": false,
   "type": "module",
   "authors": [
     "Laurin Weger"
   ],
   "license": "MIT/Apache-2.0",
-  "main": "./dist/index.js",
+  "main": "./dist/core.js",
   "exports": {
     ".": {
+      "types": "./dist/core.d.ts",
+      "default": "./dist/core.js"
+    },
+    "./all": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
@@ -33,47 +37,44 @@
   "publishConfig": {
     "access": "public"
   },
-  "optionalDependencies": {
+  "peerDependencies": {
     "react": "^19.0.0 || ^18.0.0",
-    "svelte": "^5.0.0",
+    "svelte": "^5.0.0 || ^4.0.0 || ^3.0.0",
     "vue": "^3.0.0"
   },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
   "dependencies": {
-    "@gn8/alien-signals-react": "^0.1.1",
-    "@gn8/alien-signals-solid": "^0.1.1",
-    "@gn8/alien-signals-svelte": "^0.1.1",
-    "@gn8/alien-signals-vue": "^0.1.1",
-    "@types/react": "19.1.10",
-    "@types/react-dom": "19.1.7",
-    "@types/shexj": "^2.1.7",
-    "alien-signals": "^2.0.7",
-    "install": "^0.13.0",
-    "npm": "^11.5.2",
-    "prettier-eslint": "^16.4.2",
-    "@ng-org/shex-orm": "0.1.2-alpha.5",
-    "@ng-org/alien-deepsignals": "0.1.2-alpha.7"
+    "@ng-org/alien-deepsignals": "0.1.2-alpha.9"
   },
   "devDependencies": {
-    "@playwright/test": "^1.55.0",
-    "@types/node": "24.3.0",
-    "@types/react": "19.1.10",
-    "@types/react-dom": "19.1.7",
-    "vite": "7.1.3",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "vite": "7.3.1",
     "vitest": "^3.2.4",
     "typescript": "^5.3.0",
-    "react": "19.1.1",
-    "react-dom": "19.1.1",
-    "svelte": "5.39.12",
-    "vue": "3.5.19",
-    "@ng-org/lib-wasm": "0.1.2-alpha.2"
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "svelte": "^5.39.12",
+    "vue": "^3.5.19",
+    "@ng-org/shex-orm": "0.1.2-alpha.6",
+    "@ng-org/web": "0.1.2-alpha.9"
   },
   "files": [
     "dist"
   ],
   "scripts": {
     "test": "vitest",
-    "test:e2e": "playwright test",
     "build:ts": "rm -rf dist && tsc"
   },
-  "types": "./dist/index.d.ts"
+  "types": "./dist/core.d.ts"
 }