@abloatai/ablo 0.26.0 → 0.27.0

package/dist/types/index.js

@@ -1,12 +1,12 @@
 /**
- * Linear Sync Engine - Core Types
+ * Core type definitions for the model-driven sync layer.
  *
- * Foundational type definitions for the model-driven sync architecture.
- * These types define how properties are tracked, loaded, and synchronized.
+ * These types describe how a model's properties are declared, when their data
+ * is loaded, and how changes are represented on the wire as they synchronize.
  */
 /**
- * Model Scope - lifecycle filter for queries.
- * Controls whether live, archived, or all entities are returned.
+ * A lifecycle filter for queries: whether to return live entities, archived
+ * ones, or both.
  */
 export var ModelScope;
 (function (ModelScope) {
@@ -15,45 +15,45 @@ export var ModelScope;
     ModelScope["all"] = "all";
 })(ModelScope || (ModelScope = {}));
 /**
- * Property Types - EXACTLY 7 types as per Linear Sync Engine
- * These define how model properties behave in the sync system
+ * The kinds of property a model can declare. Each kind determines how the
+ * property behaves in the sync system — whether it is persisted, how it relates
+ * to other models, and how it is loaded.
  */
 export var PropertyType;
 (function (PropertyType) {
-    /** Standard observable property - owned by model, persisted and synced */
+    /** A standard observable field owned by the model, both persisted and synced. */
     PropertyType["property"] = "property";
-    /** Property that doesn't persist or sync - runtime only */
+    /** A runtime-only field that is neither persisted nor synced. */
     PropertyType["ephemeralProperty"] = "ephemeralProperty";
-    /** Foreign key reference - stores ID only */
+    /** A foreign-key reference that stores only the related model's id. */
     PropertyType["reference"] = "reference";
-    /** Lazy-loaded model reference - getter/setter for model based on ID */
+    /** A single related model resolved on demand from its id, exposed as a getter and setter. */
     PropertyType["referenceModel"] = "referenceModel";
-    /** Collection of related models - one-to-many relationship */
+    /** A collection of related models — the many side of a one-to-many relationship. */
     PropertyType["referenceCollection"] = "referenceCollection";
-    /** Back-reference computed property - inverse relationship */
+    /** A computed field that follows a relationship in the inverse direction. */
     PropertyType["backReference"] = "backReference";
-    /** Array of foreign key references - many-to-many relationship */
+    /** An array of foreign-key ids — a many-to-many relationship. */
     PropertyType["referenceArray"] = "referenceArray";
 })(PropertyType || (PropertyType = {}));
 /**
- * Load Strategies - EXACTLY 5 strategies as per Linear Sync Engine
- * Controls when and how model data is loaded from the server
+ * When and how a model's data is loaded from the server.
  */
 export var LoadStrategy;
 (function (LoadStrategy) {
-    /** Load immediately into ObjectPool during bootstrap - for critical models */
+    /** Loaded during startup, before it is first used — for models needed right away. */
     LoadStrategy["instant"] = "instant";
-    /** Load all at once when first needed - for secondary models */
+    /** Loaded all at once the first time it is needed — for secondary models. */
     LoadStrategy["lazy"] = "lazy";
-    /** Load on demand in subsets - for large collections */
+    /** Loaded on demand in subsets — for large collections. */
     LoadStrategy["partial"] = "partial";
-    /** Only load when explicitly requested - for optional data */
+    /** Loaded only when the application asks for it — for optional data. */
     LoadStrategy["explicitlyRequested"] = "explicitlyRequested";
-    /** Never sync with server, local only - for client-side state */
+    /** Never synced with the server; kept only on the client — for local-only state. */
     LoadStrategy["local"] = "local";
 })(LoadStrategy || (LoadStrategy = {}));
 /**
- * Mutation operation types for batch mutations.
+ * The operation a batch mutation performs on a model row.
  */
 export var MutationOperationType;
 (function (MutationOperationType) {

package/dist/types/modelData.d.ts

@@ -1,12 +1,10 @@
 /**
- * ModelData — the generic record shape for model payloads.
+ * The generic record shape for a model's data — a map from field name to value.
  *
- * Lives in its own dependency-free leaf so BOTH `BaseSyncedStore` and
- * `SyncClient` can import it without importing each other. (The alias
- * used to live in BaseSyncedStore.ts, which made SyncClient.ts and
- * BaseSyncedStore.ts a mutual type cycle: the store needs the SyncClient
- * class type, and SyncClient needed this alias back from the store.)
- * `BaseSyncedStore` re-exports it, so existing importers are unchanged.
+ * Because the values are typed as `unknown`, read the data as the
+ * schema-inferred entity type rather than accessing fields off this shape
+ * directly. It has no imports of its own, so any module can depend on it
+ * without creating an import cycle.
  */
-/** Generic record type for model data */
+/** A record mapping each model field name to its value. */
 export type ModelData = Record<string, unknown>;

package/dist/types/modelData.js

@@ -1,11 +1,9 @@
 /**
- * ModelData — the generic record shape for model payloads.
+ * The generic record shape for a model's data — a map from field name to value.
  *
- * Lives in its own dependency-free leaf so BOTH `BaseSyncedStore` and
- * `SyncClient` can import it without importing each other. (The alias
- * used to live in BaseSyncedStore.ts, which made SyncClient.ts and
- * BaseSyncedStore.ts a mutual type cycle: the store needs the SyncClient
- * class type, and SyncClient needed this alias back from the store.)
- * `BaseSyncedStore` re-exports it, so existing importers are unchanged.
+ * Because the values are typed as `unknown`, read the data as the
+ * schema-inferred entity type rather than accessing fields off this shape
+ * directly. It has no imports of its own, so any module can depend on it
+ * without creating an import cycle.
  */
 export {};

package/dist/types/participant.d.ts

@@ -1,19 +1,18 @@
 /**
- * Participant identity — a zero-import leaf of the type graph.
+ * The identity of a participant — a person's session, an AI agent, or a system
+ * actor — in the coordination protocol.
  *
- * `ParticipantRef` (and the participant-kind literals it carries) is the one
- * identity shape shared by the streams surface (`types/streams.ts`) and the
- * conflict-policy layer (`policy/types.ts`). It lives in its own leaf module —
- * importing nothing — so both layers can depend on it without forming the
- * foundation triangle `types/streams → schema/model → policy/types →
- * types/streams`. The runtime validator for the same literals stays in
- * `coordination/schema.ts` (`participantKindSchema`).
+ * {@link ParticipantRef} is the single identity shape shared by the streams
+ * types and the conflict-policy types. It has no imports of its own, so both
+ * can depend on it without creating an import cycle. The runtime validator for
+ * the same participant kinds lives alongside the other coordination schemas.
  */
-/** The participant-kind vocabulary: human session, AI agent, or system actor. */
+/** The kind of actor a participant is: a human session, an AI agent, or a system actor. */
 export type ParticipantKind = 'user' | 'agent' | 'system';
 /**
- * Identity reference for an actor / on-behalf-of slot. Generic
- * protocol vocabulary; works for sessions, agents, and system roles.
+ * A reference to one participant: its {@link ParticipantKind} and its id. Used
+ * both for the actor performing an action and for the participant it acts on
+ * behalf of.
  */
 export interface ParticipantRef {
     kind: ParticipantKind;

package/dist/types/participant.js

@@ -1,12 +1,10 @@
 /**
- * Participant identity — a zero-import leaf of the type graph.
+ * The identity of a participant — a person's session, an AI agent, or a system
+ * actor — in the coordination protocol.
  *
- * `ParticipantRef` (and the participant-kind literals it carries) is the one
- * identity shape shared by the streams surface (`types/streams.ts`) and the
- * conflict-policy layer (`policy/types.ts`). It lives in its own leaf module —
- * importing nothing — so both layers can depend on it without forming the
- * foundation triangle `types/streams → schema/model → policy/types →
- * types/streams`. The runtime validator for the same literals stays in
- * `coordination/schema.ts` (`participantKindSchema`).
+ * {@link ParticipantRef} is the single identity shape shared by the streams
+ * types and the conflict-policy types. It has no imports of its own, so both
+ * can depend on it without creating an import cycle. The runtime validator for
+ * the same participant kinds lives alongside the other coordination schemas.
  */
 export {};