@mastra/libsql 0.0.0-testing-cloud-studios-20260114234039 → 0.0.0-thread-replay-alpha-20261102163541

package/LICENSE.md

@@ -1,3 +1,20 @@
+Portions of this software are licensed as follows:
+
+- All content that resides under any directory named `ee/` within this
+  repository, including but not limited to:
+  - `@mastra/core/auth/ee`
+  - `@mastra/core/agent-builder/ee`
+  - `@mastra/editor/ee`
+
+  is licensed under the license defined in [`ee/LICENSE`](https://github.com/mastra-ai/mastra/blob/main/ee/LICENSE).
+
+- All third-party components incorporated into the Mastra Software are
+  licensed under the original license provided by the owner of the
+  applicable component.
+
+- Content outside of the above-mentioned directories or restrictions is
+  available under the "Apache License 2.0" as defined below.
+
 # Apache License 2.0
 
 Copyright (c) 2025 Kepler Software, Inc.

package/README.md

@@ -16,27 +16,30 @@ npm install @mastra/libsql
 import { LibSQLVector } from '@mastra/libsql';
 
 const vectorStore = new LibSQLVector({
-  url: 'file:./my-db.db'
+  url: 'file:./my-db.db',
 });
 
 // Create a new table with vector support
 await vectorStore.createIndex({
   indexName: 'my_vectors',
-  dimension: 1536,
+  dimension: 3,
   metric: 'cosine',
 });
 
 // Add vectors
 const ids = await vectorStore.upsert({
   indexName: 'my_vectors',
-  vectors: [[0.1, 0.2, ...], [0.3, 0.4, ...]],
+  vectors: [
+    [0.1, 0.2, 0.3],
+    [0.3, 0.4, 0.5],
+  ],
   metadata: [{ text: 'doc1' }, { text: 'doc2' }],
 });
 
 // Query vectors
 const results = await vectorStore.query({
   indexName: 'my_vectors',
-  queryVector: [0.1, 0.2, ...],
+  queryVector: [0.1, 0.2, 0.3],
   topK: 10, // topK
   filter: { text: 'doc1' }, // filter
   includeVector: false, // includeVector
@@ -44,111 +47,14 @@ const results = await vectorStore.query({
 });
 ```
 
-### Storage
-
-```typescript
-import { LibSQLStore } from '@mastra/libsql';
-
-const store = new LibSQLStore({
-  id: 'libsql-storage',
-  url: 'file:./my-db.db',
-});
-
-// Create a thread
-await store.saveThread({
-  thread: {
-    id: 'thread-123',
-    resourceId: 'resource-456',
-    title: 'My Thread',
-    metadata: { key: 'value' },
-    createdAt: new Date(),
-  },
-});
-
-// Add messages to thread
-await store.saveMessages({
-  messages: [
-    {
-      id: 'msg-789',
-      threadId: 'thread-123',
-      role: 'user',
-      content: { content: 'Hello' },
-      resourceId: 'resource-456',
-      createdAt: new Date(),
-    },
-  ],
-});
-
-// Query threads and messages
-const savedThread = await store.getThreadById({ threadId: 'thread-123' });
-const messages = await store.listMessages({ threadId: 'thread-123' });
-```
-
-## Configuration
-
-The LibSQLStore store can be initialized with:
-
-- Configuration object with url and auth. Auth is only necessary when using a provider like [Turso](https://turso.tech/)
-
-## Features
-
-### Vector Store Features
-
-- Vector similarity search with cosine, euclidean, and dot product metrics
-- Advanced metadata filtering with MongoDB-like query syntax
-- Minimum score threshold for queries
-- Automatic UUID generation for vectors
-- Table management (create, list, describe, delete, truncate)
-
-### Storage Features
-
-- Thread and message storage with JSON support
-- Atomic transactions for data consistency
-- Efficient batch operations
-- Rich metadata support
-- Timestamp tracking
-- Cascading deletes
-
-## Supported Filter Operators
-
-The following filter operators are supported for metadata queries:
-
-- Comparison: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`
-- Logical: `$and`, `$or`
-- Array: `$in`, `$nin`
-- Text: `$regex`, `$like`
-
-Example filter:
-
-```typescript
-{
-  $and: [{ age: { $gt: 25 } }, { tags: { $in: ['tag1', 'tag2'] } }];
-}
-```
-
-## Vector Store Methods
+## Documentation
 
-- `createIndex({indexName, dimension, metric?, indexConfig?, defineIndex?})`: Create a new table with vector support
-- `upsert({indexName, vectors, metadata?, ids?})`: Add or update vectors
-- `query({indexName, queryVector, topK?, filter?, includeVector?, minScore?})`: Search for similar vectors
-- `updateVector({ indexName, id?, filter?, update })`: Update a single vector by ID or metadata filter
-- `deleteVector({ indexName, id })`: Delete a single vector by ID
-- `deleteVectors({ indexName, ids?, filter? })`: Delete multiple vectors by IDs or metadata filter
-- `defineIndex({indexName, metric?, indexConfig?})`: Define an index
-- `listIndexes()`: List all vector-enabled tables
-- `describeIndex(indexName)`: Get table statistics
-- `deleteIndex(indexName)`: Delete a table
-- `truncateIndex(indexName)`: Remove all data from a table
+- [@mastra/libsql documentation](https://mastra.ai/integrations/vectors/libsql)
 
-## Storage Methods
+## Changelog
 
-- `saveThread({ thread })`: Create or update a thread
-- `getThreadById({ threadId })`: Get a thread by ID
-- `deleteThread({ threadId })`: Delete a thread and its messages
-- `saveMessages({ messages })`: Save multiple messages in a transaction
-- `listMessages({ threadId, perPage?, page? })`: Get messages for a thread with pagination
-- `deleteMessages(messageIds)`: Delete specific messages
+See the [package changelog](https://github.com/mastra-ai/mastra/blob/main/stores/libsql/CHANGELOG.md) for version history and release notes.
 
-## Related Links
+## Support
 
-- [LibSQL Documentation](https://docs.turso.tech/sdk/introductionh)
+We have an [open community Discord](https://discord.gg/mastra-ai). Come and say hello and let us know if you have any questions or need any help getting things running.

package/dist/_types/@internal_core/dist/knowledge-compat/index.d.ts

@@ -0,0 +1,338 @@
+export declare const KNOWLEDGE_STORAGE_CONTRACT_VERSION: 4;
+export declare const KNOWLEDGE_STORAGE_SCHEMA_VERSION: 4;
+export declare const TABLE_KNOWLEDGE_NODE_SCOPES = "mastra_knowledge_node_scopes";
+export declare const TABLE_KNOWLEDGE_RECORD_SCOPES = "mastra_knowledge_record_scopes";
+export declare const TABLE_KNOWLEDGE_SCOPE_GRANTS = "mastra_knowledge_scope_grants";
+export declare const TABLE_KNOWLEDGE_ACCESS_STATE = "mastra_knowledge_access_state";
+export declare const TABLE_KNOWLEDGE_SCOPE_ADDRESSES = "mastra_knowledge_scope_addresses";
+export declare const TABLE_KNOWLEDGE_NODE_ADDRESSES = "mastra_knowledge_node_addresses";
+export declare const TABLE_KNOWLEDGE_IMPORT_STATE = "mastra_knowledge_import_state";
+export declare const TABLE_KNOWLEDGE_IMPORT_RUNS = "mastra_knowledge_import_runs";
+export declare const TABLE_KNOWLEDGE_PROPOSALS = "mastra_knowledge_proposals";
+export declare const KNOWLEDGE_TABLE_NAMES: readonly ["mastra_knowledge_nodes", "mastra_knowledge_records", "mastra_knowledge_mentions", "mastra_knowledge_activity", "mastra_knowledge_semantic_outbox", "mastra_knowledge_node_scopes", "mastra_knowledge_record_scopes", "mastra_knowledge_scope_grants", "mastra_knowledge_access_state", "mastra_knowledge_scope_addresses", "mastra_knowledge_node_addresses", "mastra_knowledge_import_state", "mastra_knowledge_import_runs", "mastra_knowledge_proposals"];
+/** Knowledge v1 tables with no v2 equivalent; an explicit schema reset drops them. */
+export declare const RETIRED_KNOWLEDGE_TABLE_NAMES: readonly ['mastra_knowledge_cursors'];
+export declare const KNOWLEDGE_PAGES_CORE_FEATURE = "knowledge-pages";
+export declare const KNOWLEDGE_PAGES_SCHEMA_VERSION: 4;
+export declare const TABLE_KNOWLEDGE_PAGES = "mastra_knowledge_pages";
+export declare const TABLE_KNOWLEDGE_NOTES = "mastra_knowledge_notes";
+export declare const TABLE_KNOWLEDGE_NOTE_STAMPS = "mastra_knowledge_note_stamps";
+/** Same name as the schema-2 table; schema 4 re-keys it to note → page. */
+export declare const TABLE_KNOWLEDGE_PAGE_MENTIONS = "mastra_knowledge_mentions";
+export declare const TABLE_KNOWLEDGE_PINS = "mastra_knowledge_pins";
+/** Same name as schema 2; schema 4 re-keys it to scope/page/note. */
+export declare const TABLE_KNOWLEDGE_PAGE_ACTIVITY = "mastra_knowledge_activity";
+/** Holds `{ id: 'knowledge', schemaVersion: 4 }`, written when the schema-4 tables are created. */
+export declare const TABLE_KNOWLEDGE_PAGES_STATE = "mastra_knowledge_access_state";
+export declare const KNOWLEDGE_PAGES_TABLE_NAMES: readonly ["mastra_knowledge_pages", "mastra_knowledge_notes", "mastra_knowledge_note_stamps", "mastra_knowledge_mentions", "mastra_knowledge_pins", "mastra_knowledge_activity", "mastra_knowledge_access_state"];
+/** Every Knowledge table any schema version created. Reset drops these and nothing else. */
+export declare const KNOWLEDGE_RESETTABLE_TABLE_NAMES: readonly string[];
+/** Schema-1/2 tables whose presence means the store needs a reset before schema 4 can run. */
+export declare const LEGACY_KNOWLEDGE_TABLE_NAMES: ReadonlySet<string>;
+/** Pages and scope pages. `scopeId` equals `id` on scope pages; `address`/`declaration` only on scope pages. */
+export declare const KNOWLEDGE_PAGES_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly scopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly parentId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly isScope: {
+    readonly type: 'boolean';
+    readonly nullable: false;
+  };
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly declaration: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly key: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly position: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly name: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly canonicalName: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly description: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly body: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly mergedInto: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly createdBy: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly updatedBy: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+export declare const KNOWLEDGE_NOTES_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+  readonly text: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly when: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly provenance: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+/** One row per (note, stamp scope). Primary key is the pair. */
+export declare const KNOWLEDGE_NOTE_STAMPS_SCHEMA: {
+  readonly noteId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_notes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+};
+/** One row per (note, mentioned page). Primary key is the pair. */
+export declare const KNOWLEDGE_PAGE_MENTIONS_SCHEMA: {
+  readonly noteId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_notes";
+      readonly column: 'id';
+    };
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+};
+/** `audience` is a JSON array of scope addresses (PG may store it as `text[]`, Mongo as an array). */
+export declare const KNOWLEDGE_PINS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+  readonly audience: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly createdBy: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+export declare const KNOWLEDGE_PAGE_ACTIVITY_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly scopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly noteId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly provenance: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+export declare const KNOWLEDGE_PAGES_STATE_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly schemaVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+};
+export type KnowledgePagesSchemaInspection = {
+  status: 'compatible';
+  schemaVersion: typeof KNOWLEDGE_PAGES_SCHEMA_VERSION;
+} | {
+  status: 'uninitialized';
+  schemaVersion: null;
+} | {
+  status: 'incompatible-reset-required';
+  schemaVersion: number | null;
+  reason: string;
+};
+/**
+ * Classifies what an adapter found before creating schema-4 tables. `tableNames` is every
+ * `mastra_knowledge_*` table present; `schemaVersion` is the state row's version, if any.
+ */
+export declare function inspectKnowledgePagesSchema(snapshot: {
+  tableNames: readonly string[];
+  schemaVersion?: number;
+}): KnowledgePagesSchemaInspection;
+/**
+ * The old Knowledge tables an adapter drops on init, rows included: Knowledge before schema 4 was an
+ * experimental store with no migration. Every schema-1/2-only table present is dropped. The table
+ * names schema 4 reuses (mentions, activity, the state table) are dropped too, but only when an old
+ * table is present and no schema-4 state row exists, so they are old-shaped. Schema-4-only tables
+ * are never listed. On a schema-4 store this lists only tables an older process recreated during a
+ * rolling deploy. Drop order is safe for adapters that enforce references.
+ */
+export declare function legacyKnowledgeTablesToDrop(snapshot: {
+  tableNames: readonly string[];
+  schemaVersion?: number;
+}): string[];
+/** Message for the error an adapter throws on `incompatible-reset-required`. */
+export declare function knowledgePagesResetMessage(reason: string): string;
+/**
+ * The page-store runtime pieces adapters take from `@mastra/core/storage`. They are loaded through
+ * `createKnowledgePagesCoreLoader` instead of static imports so adapters keep loading on cores
+ * older than the `knowledge-pages` feature without raising their `@mastra/core` peer floor.
+ */
+export interface KnowledgePagesCore {
+  assertKnowledgePageDescriptionWithinBound(description: string | undefined): void;
+  assertKnowledgeNoteTextWithinBound(text: string): void;
+  canonicalKnowledgeName(name: string): string;
+  knowledgePositionBetween(before?: string, after?: string): string;
+  MAX_KNOWLEDGE_MOVE_PAGES: number;
+  MAX_KNOWLEDGE_PAGE_DEPTH: number;
+  MAX_KNOWLEDGE_PAGE_LIST_LIMIT: number;
+  KnowledgeMoveTooLargeError: new (pageId: string, pages: number) => Error;
+  KnowledgePageDepthError: new (pageId: string) => Error;
+  KnowledgePageHasChildrenError: new (pageId: string) => Error;
+  KnowledgePageKeyConflictError: new (key: string, parentId: string) => Error;
+}
+/** Loads core's page-store runtime once, after checking core advertises `knowledge-pages`. */
+export declare function createKnowledgePagesCoreLoader(features: ReadonlySet<string>, loadStorageModule: () => Promise<unknown>): () => Promise<KnowledgePagesCore>;
+/**
+ * Keyword-search words: the query split on whitespace, lowercased, deduplicated. Every word must
+ * appear (as a case-insensitive substring) in a hit; an empty list means the search returns nothing.
+ */
+export declare function knowledgeSearchWords(query: string): string[];
+/**
+ * Why `key` can't be a Knowledge page key, or undefined when it can. Keys are one path segment:
+ * non-empty, with no `/` (path separator), `#` (scope/path separator) or `%` (escape character).
+ */
+export declare function knowledgePageKeyProblem(key: string): string | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_core/dist/memory/index.d.ts

@@ -0,0 +1,101 @@
+/** Merge working memory patches: null deletes keys, arrays replace. */
+export declare function deepMergeWorkingMemory(existing: Record<string, unknown> | null | undefined, update: Record<string, unknown> | null | undefined): Record<string, unknown>;
+/**
+ * Shared rules for observational memory lifecycle writes. Every storage adapter applies
+ * these inside its own atomic section (lock, transaction, or conditional update), so the
+ * decisions are identical across adapters.
+ */
+/**
+ * Observational memory columns that lifecycle writes depend on. Storage adapters merge these
+ * into the table schema they get from `@mastra/core`, so the columns exist even when the
+ * installed core predates them.
+ */
+export declare const OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS: {
+  readonly supersededBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+/** `schema` plus {@link OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS}; `undefined` when `schema` is. */
+export declare function withObservationalMemoryLifecycleColumns<T extends object>(schema: T | undefined): (T & typeof OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS) | undefined;
+/**
+ * Result of `commitActiveObservations`.
+ */
+export interface UpdateActiveObservationsResult {
+  /** Whether the observations were written. */
+  applied: boolean;
+  /**
+   * Why nothing was written: `retired` — the target record was superseded by a newer
+   * generation; `conflict` — `expectedActiveObservations` no longer matches the stored text.
+   */
+  reason?: 'retired' | 'conflict';
+}
+/**
+ * Result of `appendBufferedObservations`.
+ *
+ * The append targets the head generation: when `input.id` was superseded, the chunk is
+ * appended to the current head instead. The append is skipped (`persisted: false`) when the
+ * head already holds a chunk with the same `cycleId`, or when the chunk is wholly covered by
+ * the head's cursor. Chunks carry `lastObservedAt = max message time + 1ms`, so a chunk is
+ * wholly covered iff `head.lastObservedAt >= chunk.lastObservedAt - 1ms`.
+ */
+export interface UpdateBufferedObservationsResult {
+  /** Whether the chunk was stored. */
+  persisted: boolean;
+  /** The record the chunk was written to (or would have been written to). */
+  recordId: string;
+}
+/** The fields of an observational memory record that decide head order. */
+export interface ObservationalMemoryHeadOrderFields {
+  generationCount: number;
+  createdAt: Date | string;
+  id: string;
+}
+/**
+ * Canonical head order: `generationCount DESC, createdAt ASC, id ASC`.
+ * Returns a negative number when `a` sorts before `b` (i.e. `a` is the better head candidate).
+ */
+export declare function compareObservationalMemoryHeadOrder(a: ObservationalMemoryHeadOrderFields, b: ObservationalMemoryHeadOrderFields): number;
+/**
+ * A buffered chunk stores `lastObservedAt = max message time + 1ms`. It is wholly covered
+ * (every message it observed is already at or before the cursor) iff
+ * `cursor >= chunk.lastObservedAt - 1ms`.
+ */
+export declare function isBufferedChunkCoveredByCursor(chunkLastObservedAt: Date | string, cursor: Date | string | null | undefined): boolean;
+/** The later of two cursors; `undefined` only when both are absent. */
+export declare function maxObservationCursor(a: Date | string | null | undefined, b: Date | string | null | undefined): Date | undefined;
+export interface ReflectionTextPlan {
+  /** `equal`: stored text equals the snapshot. `append`: observations were appended after the snapshot. */
+  mode: 'equal' | 'append';
+  observations: string;
+  tokenCount: number;
+}
+/**
+ * Decide the new generation's text when a reflection built from `snapshot` commits against
+ * the stored record.
+ *
+ * - Stored text equals the snapshot: the reflection replaces it.
+ * - Stored text extends the snapshot (activation only appends): the appended tail is kept
+ *   after the reflection, and its tokens are added.
+ * - Anything else (a non-append rewrite): `null` — the reflection must not be applied.
+ */
+export declare function planReflectionGenerationText(input: {
+  storedObservations: string;
+  storedObservationTokenCount: number;
+  snapshotObservations: string;
+  snapshotObservationTokenCount: number;
+  reflection: string;
+  tokenCount: number;
+}): ReflectionTextPlan | null;
+/**
+ * Backs `updateActiveObservations` in adapters that implement `commitActiveObservations`.
+ * Callers of `updateActiveObservations` (which resolves `void`) can't see a commit result, so a
+ * write that was not applied throws instead of resolving as if it had committed.
+ */
+export declare function assertActiveObservationsApplied(result: UpdateActiveObservationsResult, id: string): void;
+/**
+ * Whether the stored text can still accept a reflection built from `snapshot`
+ * (equal, or only appended to since).
+ */
+export declare function isAppendOnlySince(storedObservations: string, snapshotObservations: string): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_core/package.json

@@ -0,0 +1 @@
+{"type":"module"}