@abloatai/ablo 0.25.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) {
@@ -63,8 +63,3 @@ export var MutationOperationType;
     MutationOperationType["UNARCHIVE"] = "UNARCHIVE";
     MutationOperationType["UPDATE"] = "UPDATE";
 })(MutationOperationType || (MutationOperationType = {}));
-// Re-export stream + snapshot + principal types for the engine surface
-// (PresenceStream,
-// ClaimStream, Snapshot, etc.) consumed by `Ablo({...}).presence`,
-// `.claims`, `.snapshot()`.
-export * from "./streams.js";

package/dist/types/modelData.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The generic record shape for a model's data — a map from field name to value.
+ *
+ * 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.
+ */
+/** A record mapping each model field name to its value. */
+export type ModelData = Record<string, unknown>;

package/dist/types/modelData.js

@@ -0,0 +1,9 @@
+/**
+ * The generic record shape for a model's data — a map from field name to value.
+ *
+ * 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

@@ -0,0 +1,20 @@
+/**
+ * The identity of a participant — a person's session, an AI agent, or a system
+ * actor — in the coordination protocol.
+ *
+ * {@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 kind of actor a participant is: a human session, an AI agent, or a system actor. */
+export type ParticipantKind = 'user' | 'agent' | 'system';
+/**
+ * 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;
+    id: string;
+}

package/dist/types/participant.js

@@ -0,0 +1,10 @@
+/**
+ * The identity of a participant — a person's session, an AI agent, or a system
+ * actor — in the coordination protocol.
+ *
+ * {@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 {};