@soulcraft/cor 3.0.0-rc.1

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @soulcraft/cor — Native Rust acceleration for Brainy
+ *
+ * When installed alongside @soulcraft/brainy, this package automatically
+ * provides native Rust implementations for:
+ * - SIMD distance calculations (cosine, euclidean, manhattan, dot product)
+ * - Metadata index (full query/mutation engine in Rust)
+ * - Graph adjacency index (4 LSM-trees + verb tracking)
+ * - Entity ID mapper (UUID ↔ integer bidirectional mapping)
+ * - Roaring bitmaps (CRoaring bindings)
+ * - Embedding engine (Candle ML — CPU, CUDA, Metal)
+ * - Msgpack encoding/decoding
+ *
+ * Storage adapter: cor uses brainy's `FileSystemStorage` directly
+ * (since brainy 7.25.0 it natively provides the binary-blob primitive
+ * and multi-process locking cor used to layer on top). Cor no
+ * longer ships a storage adapter — the boundary is now razor-sharp:
+ * **brainy = data + storage**, **cor = compute accelerators**.
+ *
+ * Usage: `npm install @soulcraft/cor` — auto-detected, zero config.
+ */
+export { default } from './plugin.js';
+export { loadNativeModule, isNativeAvailable } from './native/index.js';
+export type { NativeBindings } from './native/types.js';
+export { NativeEmbeddingEngine, nativeEmbeddingEngine, cosineSimilarity } from './native/NativeEmbeddingEngine.js';
+export { RoaringBitmap32, RoaringBitmap32Iterator, roaringLibraryInitialize, roaringLibraryIsReady, SerializationFormat, DeserializationFormat } from './native/NativeRoaringBitmap32.js';
+export { NativeAggregationProvider } from './aggregation/NativeAggregationEngine.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @soulcraft/cor — Native Rust acceleration for Brainy
+ *
+ * When installed alongside @soulcraft/brainy, this package automatically
+ * provides native Rust implementations for:
+ * - SIMD distance calculations (cosine, euclidean, manhattan, dot product)
+ * - Metadata index (full query/mutation engine in Rust)
+ * - Graph adjacency index (4 LSM-trees + verb tracking)
+ * - Entity ID mapper (UUID ↔ integer bidirectional mapping)
+ * - Roaring bitmaps (CRoaring bindings)
+ * - Embedding engine (Candle ML — CPU, CUDA, Metal)
+ * - Msgpack encoding/decoding
+ *
+ * Storage adapter: cor uses brainy's `FileSystemStorage` directly
+ * (since brainy 7.25.0 it natively provides the binary-blob primitive
+ * and multi-process locking cor used to layer on top). Cor no
+ * longer ships a storage adapter — the boundary is now razor-sharp:
+ * **brainy = data + storage**, **cor = compute accelerators**.
+ *
+ * Usage: `npm install @soulcraft/cor` — auto-detected, zero config.
+ */
+// Default export: BrainyPlugin (auto-detected by brainy init())
+export { default } from './plugin.js';
+export { loadNativeModule, isNativeAvailable } from './native/index.js';
+// Re-export all native wrapper classes
+export { NativeEmbeddingEngine, nativeEmbeddingEngine, cosineSimilarity } from './native/NativeEmbeddingEngine.js';
+export { RoaringBitmap32, RoaringBitmap32Iterator, roaringLibraryInitialize, roaringLibraryIsReady, SerializationFormat, DeserializationFormat } from './native/NativeRoaringBitmap32.js';
+export { NativeAggregationProvider } from './aggregation/NativeAggregationEngine.js';
+//# sourceMappingURL=index.js.map

package/dist/legacyLayoutGuard.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @module legacyLayoutGuard
+ * @description Refuses to start when a cor 3.0 process is pointed
+ * at a directory that still holds cortex 2.x on-disk artifacts.
+ *
+ * The failure mode this prevents is the most dangerous in production:
+ * an operator deploys brainy 8.0 + cor 3.0 to a host whose data
+ * directory hasn't been migrated yet, the service starts,
+ * `brain.init()` fires, and either (a) crashes mid-init with a
+ * confusing low-level error from a shadow-page store, or (b) — worse —
+ * cortex's auto-engagement creates a new 3.0 file alongside the 2.x
+ * remnants, producing a half-migrated state that's harder to roll
+ * back than a clean stop.
+ *
+ * The guard runs at the top of `corPlugin.activate()`, before any
+ * provider registers. It scans the storage root for known cortex 2.x
+ * markers, and if any are found, throws a single error with the exact
+ * migration command the operator needs to run. **Throwing here is the
+ * point** — a service that won't start is recoverable; a service that
+ * starts on the wrong format isn't.
+ *
+ * The guard is no-op when:
+ *   - The storage adapter isn't filesystem-backed (cortex 2.x markers
+ *     are inherently filesystem-rooted; cloud adapters can't have
+ *     them).
+ *   - The storage root is empty (fresh install — no migration needed).
+ *   - Only cor 3.0 markers are present (the migration completed,
+ *     or this brain was created fresh on 3.0).
+ *
+ * The guard fires when:
+ *   - `_id_mapper/uuid_to_int.mkv` is a FILE (cortex 2.x). In cortex
+ *     3.0 this is a DIRECTORY containing the shadow-page head pointer
+ *     + base + delta.
+ *   - `_id_mapper/int_to_uuid.bin` is a FILE (cortex 2.x). Same
+ *     story — 3.0 makes this a directory.
+ *   - `_metadata/` contains the cortex 2.x JSON chunk envelope shape
+ *     without the 3.0 LSM shard subdirectory.
+ *   - HNSW provider artifacts exist alongside no DiskANN directory.
+ *
+ * Bypass: setting `COR_LEGACY_LAYOUT_GUARD=skip` (legacy `CORTEX_LEGACY_LAYOUT_GUARD` still honored) in the environment
+ * disables the guard. This exists for the migration script itself
+ * (which needs to be able to read the legacy layout to take its
+ * snapshot) and for emergency debugging. Production code should never
+ * set this.
+ */
+/**
+ * Storage shape we can inspect. Cortex plugin's
+ * `BrainyPluginContext.storage` exposes `getBinaryBlobPath` on
+ * filesystem-backed adapters; we use that to discover the root.
+ */
+interface StorageWithBlobPath {
+    getBinaryBlobPath?: (key: string) => string | null;
+}
+/**
+ * Public guard. Call at the top of `corPlugin.activate()` with
+ * the brainy storage adapter. Throws if cortex 2.x markers are
+ * present.
+ */
+export declare function assertNoLegacyLayout(storage: StorageWithBlobPath | null | undefined): void;
+/**
+ * @description Run {@link assertNoLegacyLayout} exactly once per storage
+ * adapter, from inside cor's storage-receiving provider factories.
+ *
+ * This is the load-bearing entry point under brainy 8.0. The plugin
+ * `activate(context)` hook receives a context that does **not** expose
+ * the brain's storage — it carries only `registerProvider` + `version` —
+ * so a guard call there scans `undefined` and silently passes, defeating
+ * the safety net. The storage adapter is only handed to the *provider
+ * factories* (`metadataIndex`, `graphIndex`, `entityIdMapper`), which
+ * brainy calls during `brain.init()`, before any of those native engines
+ * open files under the brain root. Calling this at the top of each such
+ * factory makes the cortex-2.x guard fire at the right moment, against
+ * the real storage, on whichever factory brainy constructs first.
+ *
+ * A loud "service won't start" failure is recoverable; letting cor 3.0
+ * auto-engagement run alongside 2.x remnants produces a half-migrated
+ * state that's harder to undo. Bypass via env `COR_LEGACY_LAYOUT_GUARD=skip`
+ * (legacy `CORTEX_LEGACY_LAYOUT_GUARD` still honored) for the migration
+ * script itself.
+ *
+ * @param storage - The brainy storage adapter passed to a provider
+ *   factory. Non-object / nullish values no-op (defensive).
+ * @throws If cortex 2.x on-disk markers are found under the storage root
+ *   (see {@link assertNoLegacyLayout}).
+ * @example
+ * context.registerProvider('graphIndex', (storage) => {
+ *   guardLegacyLayoutOnce(storage)
+ *   return new NativeGraphAdjacencyIndex(storage)
+ * })
+ */
+export declare function guardLegacyLayoutOnce(storage: StorageWithBlobPath | null | undefined): void;
+export {};
+//# sourceMappingURL=legacyLayoutGuard.d.ts.map

package/dist/legacyLayoutGuard.js

@@ -0,0 +1,237 @@
+/**
+ * @module legacyLayoutGuard
+ * @description Refuses to start when a cor 3.0 process is pointed
+ * at a directory that still holds cortex 2.x on-disk artifacts.
+ *
+ * The failure mode this prevents is the most dangerous in production:
+ * an operator deploys brainy 8.0 + cor 3.0 to a host whose data
+ * directory hasn't been migrated yet, the service starts,
+ * `brain.init()` fires, and either (a) crashes mid-init with a
+ * confusing low-level error from a shadow-page store, or (b) — worse —
+ * cortex's auto-engagement creates a new 3.0 file alongside the 2.x
+ * remnants, producing a half-migrated state that's harder to roll
+ * back than a clean stop.
+ *
+ * The guard runs at the top of `corPlugin.activate()`, before any
+ * provider registers. It scans the storage root for known cortex 2.x
+ * markers, and if any are found, throws a single error with the exact
+ * migration command the operator needs to run. **Throwing here is the
+ * point** — a service that won't start is recoverable; a service that
+ * starts on the wrong format isn't.
+ *
+ * The guard is no-op when:
+ *   - The storage adapter isn't filesystem-backed (cortex 2.x markers
+ *     are inherently filesystem-rooted; cloud adapters can't have
+ *     them).
+ *   - The storage root is empty (fresh install — no migration needed).
+ *   - Only cor 3.0 markers are present (the migration completed,
+ *     or this brain was created fresh on 3.0).
+ *
+ * The guard fires when:
+ *   - `_id_mapper/uuid_to_int.mkv` is a FILE (cortex 2.x). In cortex
+ *     3.0 this is a DIRECTORY containing the shadow-page head pointer
+ *     + base + delta.
+ *   - `_id_mapper/int_to_uuid.bin` is a FILE (cortex 2.x). Same
+ *     story — 3.0 makes this a directory.
+ *   - `_metadata/` contains the cortex 2.x JSON chunk envelope shape
+ *     without the 3.0 LSM shard subdirectory.
+ *   - HNSW provider artifacts exist alongside no DiskANN directory.
+ *
+ * Bypass: setting `COR_LEGACY_LAYOUT_GUARD=skip` (legacy `CORTEX_LEGACY_LAYOUT_GUARD` still honored) in the environment
+ * disables the guard. This exists for the migration script itself
+ * (which needs to be able to read the legacy layout to take its
+ * snapshot) and for emergency debugging. Production code should never
+ * set this.
+ */
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+const CORTEX_SUBDIRS = ['_id_mapper', '_metadata', '_diskann', '_graph_adjacency'];
+/**
+ * Heuristic: cortex 2.x flat-file layout markers under `_id_mapper`.
+ * Cor 3.0 makes both of these directories instead.
+ */
+const LEGACY_ID_MAPPER_FILES = [
+    '_id_mapper/uuid_to_int.mkv',
+    '_id_mapper/int_to_uuid.bin',
+];
+/**
+ * Discover the storage root directory from the brainy
+ * `StorageAdapter`. Returns null for non-filesystem adapters (no
+ * legacy markers possible).
+ */
+function resolveStorageRoot(storage) {
+    if (!storage || typeof storage.getBinaryBlobPath !== 'function')
+        return null;
+    // Ask for a sentinel path; the returned path's parent is the
+    // storage root for our purposes.
+    const probe = storage.getBinaryBlobPath('__cortex_legacy_layout_guard_probe__');
+    if (!probe)
+        return null;
+    // The probe path doesn't exist; we want its containing directory.
+    // brainy's FileSystemStorage returns something like
+    // `${rootDirectory}/__cortex_legacy_layout_guard_probe__` or
+    // `${rootDirectory}/binaryBlobs/__cortex_legacy_layout_guard_probe__`.
+    // Walk up to the directory that contains `_id_mapper` or is the
+    // brain root.
+    let dir = probe;
+    // Strip the probe filename component.
+    dir = dir.replace(/\/[^/]+$/, '');
+    // If this is `binaryBlobs/`, go one more up.
+    if (dir.endsWith('/binaryBlobs')) {
+        dir = dir.slice(0, -'/binaryBlobs'.length);
+    }
+    if (!existsSync(dir))
+        return null;
+    return dir;
+}
+function findLegacyMarkers(root) {
+    const markers = [];
+    // (1) cortex 2.x flat-file id mapper layout.
+    for (const rel of LEGACY_ID_MAPPER_FILES) {
+        const p = join(root, rel);
+        if (!existsSync(p))
+            continue;
+        const stat = statSync(p);
+        if (stat.isFile()) {
+            markers.push({
+                path: p,
+                reason: `${rel} is a file (cortex 2.x format). ` +
+                    `Cor 3.0 expects this to be a directory (shadow-page LSM store).`,
+            });
+        }
+    }
+    // (2) cortex 2.x metadata index JSON chunk files at the metadata
+    // root, with no 3.0 LSM shard subdirectory.
+    const metadataDir = join(root, '_metadata');
+    if (existsSync(metadataDir) && statSync(metadataDir).isDirectory()) {
+        const entries = readdirSync(metadataDir);
+        const hasLsmShard = entries.some((e) => e === 'memtable' || e.startsWith('lsm-'));
+        const hasJsonChunks = entries.some((e) => e.endsWith('.json') || e.endsWith('.cidx'));
+        if (hasJsonChunks && !hasLsmShard) {
+            markers.push({
+                path: metadataDir,
+                reason: `${metadataDir} contains cortex 2.x JSON chunk files (.json/.cidx) but no 3.0 LSM shard layout. ` +
+                    `Cor 3.0's metadata index is LSM-tree-backed.`,
+            });
+        }
+    }
+    // (3) HNSW provider artifacts in `_diskann/` or root without DiskANN
+    // directory. The cortex 2.x HNSW provider wrote a `.hnsw` file at
+    // the root or under a `_hnsw/` subdirectory. Cor 3.0 writes
+    // `_diskann/` instead.
+    const candidateHnsw = readdirSync(root, { withFileTypes: true })
+        .filter((e) => e.isFile())
+        .filter((e) => e.name.endsWith('.hnsw'));
+    if (candidateHnsw.length > 0 && !existsSync(join(root, '_diskann'))) {
+        markers.push({
+            path: join(root, candidateHnsw[0].name),
+            reason: `${root} contains cortex 2.x HNSW provider files (.hnsw) with no 3.0 DiskANN directory. ` +
+                `Cor 3.0 uses Adaptive DiskANN as the default vector index.`,
+        });
+    }
+    return markers;
+}
+/**
+ * Public guard. Call at the top of `corPlugin.activate()` with
+ * the brainy storage adapter. Throws if cortex 2.x markers are
+ * present.
+ */
+export function assertNoLegacyLayout(storage) {
+    // Dual-read during the cortex→cor rename: COR_ preferred, legacy CORTEX_ honored.
+    if ((process.env.COR_LEGACY_LAYOUT_GUARD ?? process.env.CORTEX_LEGACY_LAYOUT_GUARD) === 'skip') {
+        return;
+    }
+    const root = resolveStorageRoot(storage);
+    if (!root)
+        return; // non-filesystem adapter or unresolvable; nothing to check
+    if (!existsSync(root))
+        return; // fresh install
+    const markers = findLegacyMarkers(root);
+    if (markers.length === 0)
+        return;
+    // Build the error message. The point is to be SO clear that an
+    // operator can act on it without reading docs.
+    const lines = [
+        '',
+        '╔══════════════════════════════════════════════════════════════════════════╗',
+        '║ Cor 3.0 cannot start: this storage directory holds cortex 2.x data.   ║',
+        '╚══════════════════════════════════════════════════════════════════════════╝',
+        '',
+        `Storage root: ${root}`,
+        '',
+        'Cortex 2.x markers found:',
+        ...markers.map((m) => `  • ${m.reason}`),
+        '',
+        'Cor 3.0 broke the on-disk format intentionally to ship snapshot-safe',
+        'shadow-page LSM stores + Adaptive DiskANN. Reading 2.x files in 3.0 is not',
+        'supported by design.',
+        '',
+        '🚨 Do NOT delete this directory. Your data is intact in the 2.x format.',
+        '',
+        'To migrate (zero data loss, ~10 minutes for Venue-scale brains):',
+        '',
+        '  node node_modules/@soulcraft/cor/scripts/migrate-cortex-2x-to-3x.mjs \\',
+        `    --brain-dir ${root} \\`,
+        `    --backup-dir ${root}/../backups/pre-3.0`,
+        '',
+        'Full migration guide: docs/migration-3.0.md',
+        'Venue-specific worked example in docs/migration-3.0.md § Worked example — Venue',
+        '',
+        'To rollback instead: downgrade @soulcraft/brainy + @soulcraft/cortex to',
+        'your previous versions (e.g. brainy@7.31.6 cortex@2.7.0) — no data',
+        'changes have happened yet because cor 3.0 refused to start.',
+        '',
+    ];
+    throw new Error(lines.join('\n'));
+}
+/**
+ * Per-storage memo so the (filesystem-scanning) guard runs at most once
+ * per brain. brainy invokes each storage-receiving provider factory
+ * independently during `brain.init()`; without this, the same root would
+ * be re-scanned for every factory. A `WeakSet` keyed on the storage
+ * object also means distinct brains (distinct storage adapters) are each
+ * guarded independently, and the memo is collected with the brain.
+ */
+const guardedStorages = new WeakSet();
+/**
+ * @description Run {@link assertNoLegacyLayout} exactly once per storage
+ * adapter, from inside cor's storage-receiving provider factories.
+ *
+ * This is the load-bearing entry point under brainy 8.0. The plugin
+ * `activate(context)` hook receives a context that does **not** expose
+ * the brain's storage — it carries only `registerProvider` + `version` —
+ * so a guard call there scans `undefined` and silently passes, defeating
+ * the safety net. The storage adapter is only handed to the *provider
+ * factories* (`metadataIndex`, `graphIndex`, `entityIdMapper`), which
+ * brainy calls during `brain.init()`, before any of those native engines
+ * open files under the brain root. Calling this at the top of each such
+ * factory makes the cortex-2.x guard fire at the right moment, against
+ * the real storage, on whichever factory brainy constructs first.
+ *
+ * A loud "service won't start" failure is recoverable; letting cor 3.0
+ * auto-engagement run alongside 2.x remnants produces a half-migrated
+ * state that's harder to undo. Bypass via env `COR_LEGACY_LAYOUT_GUARD=skip`
+ * (legacy `CORTEX_LEGACY_LAYOUT_GUARD` still honored) for the migration
+ * script itself.
+ *
+ * @param storage - The brainy storage adapter passed to a provider
+ *   factory. Non-object / nullish values no-op (defensive).
+ * @throws If cortex 2.x on-disk markers are found under the storage root
+ *   (see {@link assertNoLegacyLayout}).
+ * @example
+ * context.registerProvider('graphIndex', (storage) => {
+ *   guardLegacyLayoutOnce(storage)
+ *   return new NativeGraphAdjacencyIndex(storage)
+ * })
+ */
+export function guardLegacyLayoutOnce(storage) {
+    if (!storage || typeof storage !== 'object')
+        return;
+    if (guardedStorages.has(storage))
+        return;
+    assertNoLegacyLayout(storage);
+    // Only memoize a CLEAN result: a storage that threw is never marked,
+    // so a legacy layout keeps failing loudly on every entry point.
+    guardedStorages.add(storage);
+}
+//# sourceMappingURL=legacyLayoutGuard.js.map

package/dist/license/constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * License constants (v2)
+ *
+ * Crypto keys are in Rust. This file keeps paths and URLs only.
+ */
+/** Default heartbeat check interval (24h) — server may override via nextCheckSeconds */
+export declare const DEFAULT_CHECK_INTERVAL_MS: number;
+/** Grace period in days after subscription lapse detected */
+export declare const GRACE_PERIOD_DAYS = 14;
+/** Online validation timeout in milliseconds */
+export declare const ONLINE_VALIDATION_TIMEOUT_MS = 10000;
+/** Portal heartbeat validation API URL */
+export declare const API_URL = "https://soulcraft.com/api/license/validate";
+/** Short code exchange API URL */
+export declare const EXCHANGE_URL = "https://soulcraft.com/api/license/exchange";
+/** Pricing URL for license purchase */
+export declare const PRICING_URL = "https://soulcraft.com/pricing?focus=pro";
+/**
+ * Pattern matching activation short codes (CO-XXXX-XXXX). The legacy `CX-`
+ * prefix is also accepted during the cortex→cor rename so codes already issued
+ * by Portal keep working; Portal issues `CO-` going forward.
+ */
+export declare const SHORT_CODE_PATTERN: RegExp;
+/** Project-local config file name */
+export declare const CONFIG_FILE = ".soulcraft.json";
+/** Project-local cache directory (gitignored) */
+export declare const CACHE_DIR = ".soulcraft";
+/** Heartbeat cache file */
+export declare const HEARTBEAT_FILE = "heartbeat.json";
+//# sourceMappingURL=constants.d.ts.map

package/dist/license/constants.js

@@ -0,0 +1,30 @@
+/**
+ * License constants (v2)
+ *
+ * Crypto keys are in Rust. This file keeps paths and URLs only.
+ */
+/** Default heartbeat check interval (24h) — server may override via nextCheckSeconds */
+export const DEFAULT_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** Grace period in days after subscription lapse detected */
+export const GRACE_PERIOD_DAYS = 14;
+/** Online validation timeout in milliseconds */
+export const ONLINE_VALIDATION_TIMEOUT_MS = 10_000;
+/** Portal heartbeat validation API URL */
+export const API_URL = 'https://soulcraft.com/api/license/validate';
+/** Short code exchange API URL */
+export const EXCHANGE_URL = 'https://soulcraft.com/api/license/exchange';
+/** Pricing URL for license purchase */
+export const PRICING_URL = 'https://soulcraft.com/pricing?focus=pro';
+/**
+ * Pattern matching activation short codes (CO-XXXX-XXXX). The legacy `CX-`
+ * prefix is also accepted during the cortex→cor rename so codes already issued
+ * by Portal keep working; Portal issues `CO-` going forward.
+ */
+export const SHORT_CODE_PATTERN = /^(?:CO|CX)-[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+/** Project-local config file name */
+export const CONFIG_FILE = '.soulcraft.json';
+/** Project-local cache directory (gitignored) */
+export const CACHE_DIR = '.soulcraft';
+/** Heartbeat cache file */
+export const HEARTBEAT_FILE = 'heartbeat.json';
+//# sourceMappingURL=constants.js.map

package/dist/license/onlineValidator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Online license heartbeat (v2)
+ *
+ * Background check against Portal API for:
+ * - Status-based subscription state (active, past_due, canceled, etc.)
+ * - Key renewal (subscription renewed, fresh JWT cached in memory)
+ * - Server-driven check intervals via nextCheckSeconds
+ *
+ * No signature verification here — that's in Rust.
+ * Default 24h heartbeat interval, 14-day grace period.
+ */
+interface HeartbeatCache {
+    lastCheck: string;
+    nextCheckAt?: string;
+    status?: string;
+    gracePeriodStart?: string;
+}
+/**
+ * Read the heartbeat cache from disk. Returns null if not found or unreadable.
+ */
+export declare function readHeartbeatCache(): Promise<HeartbeatCache | null>;
+/**
+ * Check if a grace period start timestamp is expired (> GRACE_PERIOD_DAYS old).
+ */
+export declare function isGracePeriodExpired(gracePeriodStart: string): boolean;
+/**
+ * Perform background heartbeat check.
+ *
+ * Call this after successful Rust validation. Non-blocking (fire and forget).
+ * Returns a warning string if the user should be notified.
+ * Returns degrade: true if the license is suspended or the grace period has expired.
+ *
+ * @param token - License key token
+ * @param options.forceCheck - Skip interval check, always call API (use at process startup)
+ */
+export declare function performHeartbeat(token: string, options?: {
+    forceCheck?: boolean;
+}): Promise<{
+    warning?: string;
+    degrade?: boolean;
+}>;
+export {};
+//# sourceMappingURL=onlineValidator.d.ts.map