@abloatai/ablo 0.34.1 → 0.35.0

package/dist/core/QueryView.js

@@ -10,7 +10,7 @@
  */
 import { observable, runInAction } from 'mobx';
 import { modelAsRow } from '../Model.js';
-import { ModelScope } from '../types/index.js';
+import { ModelScope } from '../transaction/types/index.js';
 import { compareValues, binaryInsertionIndex, findIndexById, } from './queryUtils.js';
 // ---------------------------------------------------------------------------
 // QueryView

package/dist/core/StoreManager.d.ts

@@ -3,13 +3,13 @@
  * browser — one per registered model — alongside the single
  * {@link SyncActionStore} for pending changes. It creates each store from the
  * model's metadata, tracks readiness, and provisions the underlying IndexedDB
- * object stores. A model's load strategy (instant, lazy, or partial) decides
- * how and when its data is loaded.
+ * object stores. A model's load strategy — instant or lazy — decides how and
+ * when its data is loaded.
  */
 import { ModelRegistry } from '../ModelRegistry.js';
 import { ObjectStore } from '../stores/ObjectStore.js';
 import { SyncActionStore } from '../stores/SyncActionStore.js';
-import { LoadStrategy } from '../types/index.js';
+import { LoadStrategy } from '../transaction/types/index.js';
 /**
  * StoreManager - Central manager for all ObjectStore instances
  *
@@ -39,7 +39,7 @@ export declare class StoreManager {
     /**
      * Create stores (tables) in IndexedDB
      */
-    createStores(db: IDBDatabase, transaction: IDBTransaction): Promise<void>;
+    createStores(db: IDBDatabase): Promise<void>;
     /**
      * Create special tables (sync_action_table, model_table, model_table_partial, __meta, __transactions)
      */
@@ -74,25 +74,10 @@ export declare class StoreManager {
      * than scanning them all, and returns true as soon as one has records.
      */
     hasAnyData(): Promise<boolean>;
-    /**
-     * Get store type distribution for debugging
-     */
-    getStoreTypeDistribution(): {
-        full: number;
-        partial: number;
-    };
     /**
      * Get stores by load strategy
      */
     getStoresByStrategy(strategy: LoadStrategy): ObjectStore[];
-    /**
-     * Get models to load for bootstrapping
-     */
-    getModelsToLoad(): {
-        instant: string[];
-        lazy: string[];
-        partial: string[];
-    };
     /**
      * Perform maintenance on all stores
      */
@@ -111,10 +96,6 @@ export declare class StoreManager {
      */
     getComprehensiveStats(): Promise<{
         totalStores: number;
-        storeTypes: {
-            full: number;
-            partial: number;
-        };
         readiness: {
             ready: number;
             notReady: number;

package/dist/core/StoreManager.js

@@ -3,14 +3,14 @@
  * browser — one per registered model — alongside the single
  * {@link SyncActionStore} for pending changes. It creates each store from the
  * model's metadata, tracks readiness, and provisions the underlying IndexedDB
- * object stores. A model's load strategy (instant, lazy, or partial) decides
- * how and when its data is loaded.
+ * object stores. A model's load strategy — instant or lazy — decides how and
+ * when its data is loaded.
  */
 import { ModelRegistry } from '../ModelRegistry.js';
 import { ObjectStore } from '../stores/ObjectStore.js';
 import { SyncActionStore } from '../stores/SyncActionStore.js';
-import { LoadStrategy } from '../types/index.js';
-import { AbloValidationError } from '../errors.js';
+import { LoadStrategy } from '../transaction/types/index.js';
+import { AbloValidationError } from '../transaction/errors.js';
 /**
  * StoreManager - Central manager for all ObjectStore instances
  *
@@ -63,9 +63,6 @@ export class StoreManager {
             count: this.stores.size,
             ms: duration.toFixed(2),
         });
-        // Log store distribution
-        const storeTypes = this.getStoreTypeDistribution();
-        getContext().logger.debug('Store distribution', storeTypes);
     }
     /**
      * Create ObjectStore for a specific model
@@ -86,11 +83,10 @@ export class StoreManager {
     /**
      * Create stores (tables) in IndexedDB
      */
-    async createStores(db, transaction) {
+    async createStores(db) {
         getContext().logger.info('Creating tables for all registered models');
         for (const modelName of this.modelRegistry.getRegisteredModelNames()) {
             const storeName = modelName;
-            const metadata = this.modelRegistry.getMetadata(modelName);
             // Skip if store already exists
             if (db.objectStoreNames.contains(storeName)) {
                 continue;
@@ -111,10 +107,6 @@ export class StoreManager {
                     getContext().logger.debug('Failed to create index', { store: storeName, prop: propName, error });
                 }
             }
-            // For partial load strategy models, we'll create additional partial index database later
-            if (metadata?.loadStrategy === LoadStrategy.partial) {
-                getContext().logger.debug('Model will have additional partial index database', { modelName });
-            }
         }
         // Create special tables
         this.createSpecialTables(db);
@@ -223,23 +215,6 @@ export class StoreManager {
         }
         return false;
     }
-    /**
-     * Get store type distribution for debugging
-     */
-    getStoreTypeDistribution() {
-        let full = 0;
-        let partial = 0;
-        for (const [modelName] of Array.from(this.stores)) {
-            const metadata = this.modelRegistry.getMetadata(modelName);
-            if (metadata?.loadStrategy === LoadStrategy.partial) {
-                partial++;
-            }
-            else {
-                full++;
-            }
-        }
-        return { full, partial };
-    }
     /**
      * Get stores by load strategy
      */
@@ -253,30 +228,6 @@ export class StoreManager {
         }
         return stores;
     }
-    /**
-     * Get models to load for bootstrapping
-     */
-    getModelsToLoad() {
-        const instant = [];
-        const lazy = [];
-        const partial = [];
-        for (const [modelName] of Array.from(this.stores)) {
-            const metadata = this.modelRegistry.getMetadata(modelName);
-            switch (metadata?.loadStrategy) {
-                case LoadStrategy.instant:
-                    instant.push(modelName);
-                    break;
-                case LoadStrategy.lazy:
-                    lazy.push(modelName);
-                    break;
-                case LoadStrategy.partial:
-                    partial.push(modelName);
-                    break;
-                // Skip explicitlyRequested and local
-            }
-        }
-        return { instant, lazy, partial };
-    }
     /**
      * Perform maintenance on all stores
      */
@@ -339,7 +290,6 @@ export class StoreManager {
         }
         return {
             totalStores: this.stores.size,
-            storeTypes: this.getStoreTypeDistribution(),
             readiness: {
                 ready: readyCount,
                 notReady: this.stores.size - readyCount,

package/dist/core/index.d.ts

@@ -21,7 +21,7 @@ export { Model } from '../Model.js';
 export { LazyReferenceCollection, type LazyCollectionOptions, } from '../LazyReferenceCollection.js';
 export { ModelRegistry, getActiveRegistry, } from '../ModelRegistry.js';
 export { postQuery, type PostQueryOptions } from '../query/client.js';
-export { computeFKDepthPriority } from '../client/Ablo.js';
+export { computeFKDepthPriority } from '../client/schemaConfig.js';
 export type { SyncLogger, SyncObservabilityProvider, MutationExecutor, SessionErrorDetector, OnlineStatusProvider, CommitResult, MutationOperation, } from '../interfaces/index.js';
 export { SyncWebSocket, type SyncDelta, type SyncWebSocketOptions, } from '../sync/SyncWebSocket.js';
 export { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
@@ -30,4 +30,4 @@ export { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
 export { BootstrapFetcher as BootstrapHelper } from '../sync/BootstrapFetcher.js';
 export { createClaimStream, type AttachableClaimStream, type ClaimStreamConfig, } from '../sync/createClaimStream.js';
 export { awaitClaimGrant, type GrantTransport, } from '../sync/awaitClaimGrant.js';
-export { LoadStrategy } from '../types/index.js';
+export { LoadStrategy } from '../transaction/types/index.js';

package/dist/core/index.js

@@ -28,7 +28,7 @@ export { postQuery } from '../query/client.js';
 // Computes a dependency-safe ordering for a set of models by walking their
 // foreign-key relationships, so writes commit parents before children. Used by
 // schema-aware test fixtures and scaffolding tools.
-export { computeFKDepthPriority } from '../client/Ablo.js';
+export { computeFKDepthPriority } from '../client/schemaConfig.js';
 // The sync layer: the WebSocket wrapper and the delta shape it carries. Needed
 // when writing a sync adapter or a multi-participant test harness.
 export { SyncWebSocket, } from '../sync/SyncWebSocket.js';
@@ -45,4 +45,4 @@ export { createClaimStream, } from '../sync/createClaimStream.js';
 export { awaitClaimGrant, } from '../sync/awaitClaimGrant.js';
 // An enum naming the strategies for loading a model's data. Referenced when
 // registering models in extension code.
-export { LoadStrategy } from '../types/index.js';
+export { LoadStrategy } from '../transaction/types/index.js';

package/dist/core/storeContract.d.ts

@@ -10,7 +10,7 @@
  * the runtime bundle beyond the erased interface declarations.
  */
 import type { Model } from '../Model.js';
-import type { ModelScope } from '../types/index.js';
+import type { ModelScope } from '../transaction/types/index.js';
 import type { QueryView, QueryViewOptions } from './QueryView.js';
 import type { ViewRegistry } from './ViewRegistry.js';
 import type { ParticipantScope } from '../sync/participants.js';
@@ -42,7 +42,7 @@ export interface SyncStatus {
  */
 export interface LocalMutation {
     type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
-    /** The registered name of the mutated model, for example `'SlideLayer'`. */
+    /** The registered name of the mutated model, for example `'Block'`. */
     modelName: string;
     modelId: string;
     /** The new field values, for a create or an update. */

package/dist/docs/catalog.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The catalog of documentation this package ships.
+ *
+ * One definition of *which docs exist*, read from the files themselves. Every
+ * reader — `ablo docs`, the public `/api/docs/*` routes, the MCP docs tools —
+ * resolves through here rather than keeping its own list, because a
+ * hand-maintained index of a directory is a copy that drifts the moment a page
+ * is added and nothing fails when it does. Before this module the public web
+ * allowlist had fallen 21 pages behind the corpus, including `coordination`.
+ *
+ * Title and description are DERIVED from each file's own convention: an H1,
+ * then a one-paragraph blockquote stating what the page is for. That blockquote
+ * is the description everywhere it is needed — the site frontmatter lifts the
+ * same line — so a page states its own promise exactly once, in the source that
+ * ships in the npm tarball and still reads correctly as plain markdown.
+ *
+ * The published set mirrors the tarball's `files` globs (`docs/*.md`,
+ * `docs/examples/*.md`, plus the three root files). Anything else under `docs/`
+ * — `docs/internal/**` above all — is neither shipped nor catalogued, and that
+ * exclusion is the only thing keeping internal notes off the public routes now
+ * that they read from here.
+ */
+/** Where a page sits in the corpus, and how a reader should group it. */
+export type DocKind = 'guide' | 'example' | 'package';
+/** One documentation page, as shipped. */
+export interface DocEntry {
+    /** Stable reference: `quickstart`, `examples/nextjs`, `agents`. */
+    readonly slug: string;
+    /** Human-readable title — the file's H1, or curated for the root files. */
+    readonly title: string;
+    /** One line stating what the page is for — the file's promise blockquote. */
+    readonly description: string;
+    readonly kind: DocKind;
+    /** Absolute path on disk. */
+    readonly path: string;
+    readonly mime: string;
+}
+/**
+ * Read the catalog from a package root — the directory holding `docs/` and the
+ * three root files.
+ *
+ * The root is a parameter rather than resolved here because each reader knows
+ * it differently and they are genuinely different facts: the CLI resolves it
+ * against its own bundle inside `node_modules`, while the web app resolves it
+ * against the monorepo checkout. Nothing is cached; callers that serve many
+ * requests should memoize the returned array.
+ */
+export declare function readDocsCatalog(packageRoot: string): Promise<DocEntry[]>;
+/**
+ * Pull a page's title and promise line out of its markdown.
+ *
+ * The convention every page follows: an H1, then a blockquote paragraph saying
+ * what the page is for. A page missing either simply reports what it has — the
+ * catalog never invents prose.
+ */
+export declare function parseDocHeader(body: string): {
+    readonly title: string | null;
+    readonly description: string;
+};
+/**
+ * Resolve a reference to a page. Accepts the slug (`coordination`), a curated
+ * alias (`storage`), or a repo-relative path (`docs/coordination.md`,
+ * `AGENTS.md`) — the three forms readers actually arrive with. Returns null
+ * rather than throwing so a caller can render its own not-found.
+ */
+export declare function findDoc(catalog: readonly DocEntry[], reference: string): DocEntry | null;
+/**
+ * Slugs closest to a miss, for a "did you mean" line. Ranks by shared prefix,
+ * then substring containment — enough to catch a typo or a half-remembered
+ * name without pulling in a distance library.
+ */
+export declare function suggestSlugs(catalog: readonly DocEntry[], reference: string, limit?: number): string[];

package/dist/docs/catalog.js

@@ -0,0 +1,227 @@
+/**
+ * The catalog of documentation this package ships.
+ *
+ * One definition of *which docs exist*, read from the files themselves. Every
+ * reader — `ablo docs`, the public `/api/docs/*` routes, the MCP docs tools —
+ * resolves through here rather than keeping its own list, because a
+ * hand-maintained index of a directory is a copy that drifts the moment a page
+ * is added and nothing fails when it does. Before this module the public web
+ * allowlist had fallen 21 pages behind the corpus, including `coordination`.
+ *
+ * Title and description are DERIVED from each file's own convention: an H1,
+ * then a one-paragraph blockquote stating what the page is for. That blockquote
+ * is the description everywhere it is needed — the site frontmatter lifts the
+ * same line — so a page states its own promise exactly once, in the source that
+ * ships in the npm tarball and still reads correctly as plain markdown.
+ *
+ * The published set mirrors the tarball's `files` globs (`docs/*.md`,
+ * `docs/examples/*.md`, plus the three root files). Anything else under `docs/`
+ * — `docs/internal/**` above all — is neither shipped nor catalogued, and that
+ * exclusion is the only thing keeping internal notes off the public routes now
+ * that they read from here.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+const MARKDOWN_MIME = 'text/markdown; charset=utf-8';
+const TEXT_MIME = 'text/plain; charset=utf-8';
+/**
+ * The three files that document the package itself rather than a topic. They
+ * live at the package root, not under `docs/`, and none follows the H1 +
+ * blockquote convention — `llms.txt` opens with a prose paragraph and
+ * `README.md` with a banner — so their titles and descriptions are curated
+ * here, the one place that knows they are a different kind of artifact.
+ *
+ * Their slug is their filename, because the filename IS how these are referred
+ * to everywhere (`AGENTS.md` is an ecosystem convention, not a topic name) and
+ * because a bare word would collide: `docs/agents.md` is a published guide that
+ * the docs index cross-links as `agents`, and whichever of the two won that
+ * name would silently shadow the other. Friendlier spellings are aliases below.
+ */
+const PACKAGE_FILES = [
+    {
+        filename: 'AGENTS.md',
+        title: 'AGENTS.md',
+        description: 'The playbook a coding agent follows to install and drive Ablo without hanging on a prompt.',
+        mime: MARKDOWN_MIME,
+    },
+    {
+        filename: 'README.md',
+        title: 'README',
+        description: 'Package overview — what Ablo is and the shape of the API.',
+        mime: MARKDOWN_MIME,
+    },
+    {
+        filename: 'llms.txt',
+        title: 'llms.txt',
+        description: 'The curated single-file index of the whole API, for machine readers.',
+        mime: TEXT_MIME,
+    },
+];
+/**
+ * Curated redirects for references that are not a slug: the friendly spellings
+ * of the root files, plus the renames the public URLs carried before this
+ * module existed, kept so old links and any agent working from a cached page
+ * still resolve. Identity mappings are NOT listed — a slug resolves to itself
+ * by derivation, and restating the other 30 here would rebuild the
+ * hand-maintained list this module exists to delete.
+ */
+const SLUG_ALIASES = {
+    readme: 'README.md',
+    overview: 'README.md',
+    llms: 'llms.txt',
+    storage: 'data-sources',
+    'docs/storage.md': 'data-sources',
+};
+/**
+ * Read the catalog from a package root — the directory holding `docs/` and the
+ * three root files.
+ *
+ * The root is a parameter rather than resolved here because each reader knows
+ * it differently and they are genuinely different facts: the CLI resolves it
+ * against its own bundle inside `node_modules`, while the web app resolves it
+ * against the monorepo checkout. Nothing is cached; callers that serve many
+ * requests should memoize the returned array.
+ */
+export async function readDocsCatalog(packageRoot) {
+    const docsDir = join(packageRoot, 'docs');
+    const entries = [];
+    entries.push(...(await readDocsDirectory(docsDir, 'guide')));
+    entries.push(...(await readDocsDirectory(join(docsDir, 'examples'), 'example')));
+    for (const file of PACKAGE_FILES) {
+        const path = join(packageRoot, file.filename);
+        const body = await readFileOrNull(path);
+        if (body === null)
+            continue;
+        entries.push({
+            slug: file.filename,
+            title: file.title,
+            description: file.description,
+            kind: 'package',
+            path,
+            mime: file.mime,
+        });
+    }
+    return entries.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+/**
+ * Read one flat directory of markdown. Deliberately non-recursive: the shipped
+ * set is `docs/*.md` plus `docs/examples/*.md`, so descending would catalogue
+ * `docs/internal/**` — notes that are not in the tarball and must not reach a
+ * public route.
+ */
+async function readDocsDirectory(dir, kind) {
+    let names;
+    try {
+        const found = await readdir(dir, { withFileTypes: true });
+        names = found.filter((e) => e.isFile() && e.name.endsWith('.md')).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const name of names) {
+        const path = join(dir, name);
+        const body = await readFileOrNull(path);
+        if (body === null)
+            continue;
+        const stem = basename(name, '.md');
+        const { title, description } = parseDocHeader(body);
+        entries.push({
+            slug: kind === 'example' ? `examples/${stem}` : stem,
+            title: title ?? stem,
+            description,
+            kind,
+            path,
+            mime: MARKDOWN_MIME,
+        });
+    }
+    return entries;
+}
+/**
+ * Pull a page's title and promise line out of its markdown.
+ *
+ * The convention every page follows: an H1, then a blockquote paragraph saying
+ * what the page is for. A page missing either simply reports what it has — the
+ * catalog never invents prose.
+ */
+export function parseDocHeader(body) {
+    const heading = body.match(/^#[ \t]+(.+?)[ \t]*$/m);
+    const title = heading?.[1] ?? null;
+    const afterHeading = heading?.index === undefined ? body : body.slice(heading.index + heading[0].length);
+    const promise = afterHeading.match(/^\s*\n((?:>.*\n)+)/);
+    const description = promise?.[1]
+        ?.split('\n')
+        .filter(Boolean)
+        .map((line) => line.replace(/^>\s?/, ''))
+        .join(' ')
+        .trim() ?? '';
+    return { title, description };
+}
+/**
+ * Resolve a reference to a page. Accepts the slug (`coordination`), a curated
+ * alias (`storage`), or a repo-relative path (`docs/coordination.md`,
+ * `AGENTS.md`) — the three forms readers actually arrive with. Returns null
+ * rather than throwing so a caller can render its own not-found.
+ */
+export function findDoc(catalog, reference) {
+    const trimmed = reference.trim();
+    if (trimmed === '')
+        return null;
+    const direct = matchSlug(catalog, trimmed);
+    if (direct)
+        return direct;
+    const aliased = SLUG_ALIASES[trimmed.toLowerCase()];
+    if (aliased) {
+        const target = matchSlug(catalog, aliased);
+        if (target)
+            return target;
+    }
+    // Path form: `docs/coordination.md`, `docs/examples/nextjs.md`, `llms.txt`.
+    const asSlug = trimmed
+        .replace(/^\.?\//, '')
+        .replace(/^docs\//, '')
+        .replace(/\.(md|txt)$/i, '');
+    return matchSlug(catalog, asSlug);
+}
+function matchSlug(catalog, slug) {
+    const needle = slug.toLowerCase();
+    return catalog.find((entry) => entry.slug.toLowerCase() === needle) ?? null;
+}
+/**
+ * Slugs closest to a miss, for a "did you mean" line. Ranks by shared prefix,
+ * then substring containment — enough to catch a typo or a half-remembered
+ * name without pulling in a distance library.
+ */
+export function suggestSlugs(catalog, reference, limit = 3) {
+    const needle = reference.trim().toLowerCase();
+    if (needle === '')
+        return [];
+    return catalog
+        .map((entry) => {
+        const slug = entry.slug.toLowerCase();
+        let score = 0;
+        if (slug.includes(needle) || needle.includes(slug))
+            score += 10;
+        score += sharedPrefixLength(slug, needle);
+        return { slug: entry.slug, score };
+    })
+        .filter(({ score }) => score > 2)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+        .map(({ slug }) => slug);
+}
+function sharedPrefixLength(a, b) {
+    const max = Math.min(a.length, b.length);
+    let i = 0;
+    while (i < max && a[i] === b[i])
+        i += 1;
+    return i;
+}
+async function readFileOrNull(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/docs/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Programmatic access to the documentation this package ships.
+ *
+ * The docs travel in the npm tarball beside the code they describe, so a reader
+ * that resolves them through here is reading the pages for the version actually
+ * installed — not whatever the website is serving today. That is the whole
+ * point of the subpath: a published version is frozen, its docs are frozen with
+ * it, and `retrieve` never turns back into `get` behind a pinned dependency.
+ */
+export { readDocsCatalog, findDoc, parseDocHeader, suggestSlugs, type DocEntry, type DocKind, } from './catalog.js';

package/dist/docs/index.js

@@ -0,0 +1,10 @@
+/**
+ * Programmatic access to the documentation this package ships.
+ *
+ * The docs travel in the npm tarball beside the code they describe, so a reader
+ * that resolves them through here is reading the pages for the version actually
+ * installed — not whatever the website is serving today. That is the whole
+ * point of the subpath: a published version is frozen, its docs are frozen with
+ * it, and `retrieve` never turns back into `get` behind a pinned dependency.
+ */
+export { readDocsCatalog, findDoc, parseDocHeader, suggestSlugs, } from './catalog.js';

package/dist/environment.d.ts

@@ -1,40 +1 @@
-import { z } from 'zod';
-/**
- * The two environments an Ablo project runs in: `production` for live data and
- * `sandbox` for isolated test data. Every credential and every stored row
- * belongs to exactly one of them.
- */
-export declare const ENVIRONMENTS: readonly ["production", "sandbox"];
-/**
- * How an environment is spelled inside an API-key prefix: a `live` key acts on
- * the production environment and a `test` key acts on the sandbox. Convert
- * between this spelling and {@link Environment} with
- * {@link environmentFromKeyPrefix} and {@link environmentToKeyPrefix}.
- */
-export type KeyPrefixEnvironment = 'live' | 'test';
-/** A Zod schema that validates a value as one of the {@link ENVIRONMENTS}. */
-export declare const environmentSchema: z.ZodEnum<{
-    production: "production";
-    sandbox: "sandbox";
-}>;
-/** One of the {@link ENVIRONMENTS} — either `'production'` or `'sandbox'`. */
-export type Environment = z.infer<typeof environmentSchema>;
-/**
- * Coerces an untrusted value into a valid {@link Environment}, returning
- * `fallback` (which defaults to `'production'`) when the value is not a
- * recognized environment. Use it when reading an environment from configuration
- * or off the wire.
- */
-export declare function normalizeEnvironment(value: unknown, fallback?: Environment): Environment;
-/**
- * Maps an API-key prefix spelling to its {@link Environment}: a `'test'` key
- * operates on the sandbox, and anything else on production.
- */
-export declare function environmentFromKeyPrefix(value: KeyPrefixEnvironment): Environment;
-/**
- * Maps an {@link Environment} to the spelling used in an API-key prefix: the
- * sandbox is `'test'` and production is `'live'`.
- */
-export declare function environmentToKeyPrefix(value: Environment): KeyPrefixEnvironment;
-/** Returns true when the given environment is the sandbox. */
-export declare function isSandboxEnvironment(value: Environment): boolean;
+export * from './transaction/environment.js';

package/dist/environment.js

@@ -1,37 +1,8 @@
-import { z } from 'zod';
-/**
- * The two environments an Ablo project runs in: `production` for live data and
- * `sandbox` for isolated test data. Every credential and every stored row
- * belongs to exactly one of them.
- */
-export const ENVIRONMENTS = ['production', 'sandbox'];
-/** A Zod schema that validates a value as one of the {@link ENVIRONMENTS}. */
-export const environmentSchema = z.enum(ENVIRONMENTS);
-/**
- * Coerces an untrusted value into a valid {@link Environment}, returning
- * `fallback` (which defaults to `'production'`) when the value is not a
- * recognized environment. Use it when reading an environment from configuration
- * or off the wire.
- */
-export function normalizeEnvironment(value, fallback = 'production') {
-    const parsed = environmentSchema.safeParse(value);
-    return parsed.success ? parsed.data : fallback;
-}
-/**
- * Maps an API-key prefix spelling to its {@link Environment}: a `'test'` key
- * operates on the sandbox, and anything else on production.
- */
-export function environmentFromKeyPrefix(value) {
-    return value === 'test' ? 'sandbox' : 'production';
-}
-/**
- * Maps an {@link Environment} to the spelling used in an API-key prefix: the
- * sandbox is `'test'` and production is `'live'`.
- */
-export function environmentToKeyPrefix(value) {
-    return value === 'sandbox' ? 'test' : 'live';
-}
-/** Returns true when the given environment is the sandbox. */
-export function isSandboxEnvironment(value) {
-    return value === 'sandbox';
-}
+// Moved to @ablo/transaction (ADR 0013 — the settlement core extraction).
+// This shim re-exports it at the original path so in-package importers of
+// `../environment.js` keep working; rewire to `@ablo/transaction/environment`
+// and delete this shim once the core package is fully wired.
+//
+// Line comments on purpose: tsc copies a leading JSDoc block into the
+// published `.d.ts`, and this note names a package npm has never heard of.
+export * from './transaction/environment.js';