@feltdb/core 0.2.0 → 0.3.0

package/dist/distributed-indexing.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Distributed Indexing - Multi-node synchronization and replication
+ *
+ * Extends local indexing with distributed capabilities:
+ * - Index replication across peers
+ * - Vector clock-based consistency tracking
+ * - Conflict detection and resolution
+ * - Synchronization protocols
+ */
+export interface IndexVectorClock {
+    clock: Record<string, number>;
+}
+export interface IndexReplicationState {
+    indexName: string;
+    localVersion: IndexVectorClock;
+    peerVersions: Record<string, IndexVectorClock>;
+    replicatedPeers: Set<string>;
+    pendingSync: IndexOperation[];
+}
+export type IndexOperation = {
+    type: 'create_index';
+    name: string;
+    field: string;
+    indexType: string;
+} | {
+    type: 'update_index';
+    name: string;
+    recordId: string;
+    value: string;
+} | {
+    type: 'delete_index';
+    name: string;
+};
+export interface IndexSyncMessage {
+    sourcePeer: string;
+    targetPeer: string;
+    indexName: string;
+    version: IndexVectorClock;
+    operations: IndexOperation[];
+    timestamp: number;
+}
+export interface RemoteIndexMetadata {
+    name: string;
+    version: IndexVectorClock;
+    entryCount: number;
+    avgQueryTimeMs: number;
+    lastUpdated: number;
+}
+export interface RemoteIndexState {
+    peerId: string;
+    indexes: Record<string, RemoteIndexMetadata>;
+    lastSync: number;
+    reachable: boolean;
+}
+export type ConsistencyLevel = 'local' | 'eventual' | 'causal' | 'strong';
+export interface ReplicationStatus {
+    indexName: string;
+    replicatedTo: number;
+    totalPeers: number;
+    reachablePeers: number;
+    pendingSyncs: number;
+    consistencyLevel: ConsistencyLevel;
+}
+export interface VersionConflict {
+    indexName: string;
+    localVersion: IndexVectorClock;
+    remotePeer: string;
+    remoteVersion: IndexVectorClock;
+}
+export interface DistributedSyncStatus {
+    totalIndexes: number;
+    fullyReplicated: number;
+    partiallyReplicated: number;
+    pendingOperations: number;
+    unreachablePeers: number;
+}
+/**
+ * Distributed Index Manager - TypeScript implementation
+ */
+export declare class DistributedIndexManager {
+    private localPeerId;
+    private replicationStates;
+    private peerStates;
+    private pendingOperations;
+    constructor(localPeerId: string);
+    /**
+     * Create a replicated index
+     */
+    createReplicatedIndex(name: string, field: string, indexType: string): void;
+    /**
+     * Register a peer for replication
+     */
+    registerPeer(peerId: string): void;
+    /**
+     * Update remote peer's index metadata
+     */
+    updatePeerIndexMetadata(peerId: string, indexName: string, metadata: RemoteIndexMetadata): void;
+    /**
+     * Enqueue a sync message
+     */
+    enqueueSyncMessage(message: IndexSyncMessage): void;
+    /**
+     * Get pending sync messages for a peer
+     */
+    getPendingForPeer(peerId: string): IndexSyncMessage[];
+    /**
+     * Acknowledge sync from peer
+     */
+    acknowledgePeerSync(peerId: string, indexName: string): void;
+    /**
+     * Get replication status for an index
+     */
+    getReplicationStatus(indexName: string): ReplicationStatus | null;
+    /**
+     * Calculate consistency level for an index
+     */
+    private calculateConsistencyLevel;
+    /**
+     * Get replication targets for an index
+     */
+    getReplicationTargets(indexName: string): string[];
+    /**
+     * Detect version conflicts
+     */
+    detectConflicts(indexName: string): VersionConflict[];
+    /**
+     * Merge versions using CRDT strategy
+     */
+    mergeVersions(indexName: string): void;
+    /**
+     * Set peer reachability
+     */
+    setPeerReachable(peerId: string, reachable: boolean): void;
+    /**
+     * Get overall sync status
+     */
+    getSyncStatus(): DistributedSyncStatus;
+    /**
+     * Vector clock utilities
+     */
+    private isConcurrent;
+    private happensBefore;
+    private mergeClocks;
+}
+/**
+ * Synchronization coordinator for multi-node environments
+ */
+export declare class DistributedSyncCoordinator {
+    private indexManager;
+    private syncInterval;
+    private syncIntervalMs;
+    constructor(indexManager: DistributedIndexManager);
+    /**
+     * Start periodic synchronization
+     */
+    startSync(intervalMs?: number): void;
+    /**
+     * Stop synchronization
+     */
+    stopSync(): void;
+    /**
+     * Perform synchronization cycle
+     */
+    private performSync;
+    /**
+     * Explicitly sync a specific index
+     */
+    syncIndex(indexName: string): void;
+}
+//# sourceMappingURL=distributed-indexing.d.ts.map

package/dist/distributed-indexing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributed-indexing.d.ts","sourceRoot":"","sources":["../src/distributed-indexing.ts"],"names":[],"mappings":"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"}

package/dist/distributed-indexing.js

@@ -0,0 +1,260 @@
+/**
+ * Distributed Indexing - Multi-node synchronization and replication
+ *
+ * Extends local indexing with distributed capabilities:
+ * - Index replication across peers
+ * - Vector clock-based consistency tracking
+ * - Conflict detection and resolution
+ * - Synchronization protocols
+ */
+/**
+ * Distributed Index Manager - TypeScript implementation
+ */
+export class DistributedIndexManager {
+    constructor(localPeerId) {
+        this.replicationStates = new Map();
+        this.peerStates = new Map();
+        this.pendingOperations = [];
+        this.localPeerId = localPeerId;
+    }
+    /**
+     * Create a replicated index
+     */
+    createReplicatedIndex(name, field, indexType) {
+        const version = { clock: { [this.localPeerId]: 1 } };
+        this.replicationStates.set(name, {
+            indexName: name,
+            localVersion: version,
+            peerVersions: {},
+            replicatedPeers: new Set(),
+            pendingSync: [
+                {
+                    type: 'create_index',
+                    name,
+                    field,
+                    indexType,
+                },
+            ],
+        });
+    }
+    /**
+     * Register a peer for replication
+     */
+    registerPeer(peerId) {
+        this.peerStates.set(peerId, {
+            peerId,
+            indexes: {},
+            lastSync: Date.now(),
+            reachable: true,
+        });
+    }
+    /**
+     * Update remote peer's index metadata
+     */
+    updatePeerIndexMetadata(peerId, indexName, metadata) {
+        const peer = this.peerStates.get(peerId);
+        if (peer) {
+            peer.indexes[indexName] = metadata;
+            peer.lastSync = Date.now();
+        }
+    }
+    /**
+     * Enqueue a sync message
+     */
+    enqueueSyncMessage(message) {
+        this.pendingOperations.push(message);
+    }
+    /**
+     * Get pending sync messages for a peer
+     */
+    getPendingForPeer(peerId) {
+        return this.pendingOperations.filter((msg) => msg.targetPeer === peerId);
+    }
+    /**
+     * Acknowledge sync from peer
+     */
+    acknowledgePeerSync(peerId, indexName) {
+        const state = this.replicationStates.get(indexName);
+        if (state) {
+            state.replicatedPeers.add(peerId);
+        }
+    }
+    /**
+     * Get replication status for an index
+     */
+    getReplicationStatus(indexName) {
+        const state = this.replicationStates.get(indexName);
+        if (!state)
+            return null;
+        const totalPeers = this.peerStates.size;
+        const reachablePeers = Array.from(this.peerStates.values()).filter((p) => p.reachable).length;
+        const consistencyLevel = this.calculateConsistencyLevel(indexName);
+        return {
+            indexName,
+            replicatedTo: state.replicatedPeers.size,
+            totalPeers,
+            reachablePeers,
+            pendingSyncs: state.pendingSync.length,
+            consistencyLevel,
+        };
+    }
+    /**
+     * Calculate consistency level for an index
+     */
+    calculateConsistencyLevel(indexName) {
+        const state = this.replicationStates.get(indexName);
+        if (!state)
+            return 'local';
+        const totalPeers = this.peerStates.size;
+        const replicatedPeers = state.replicatedPeers.size;
+        if (replicatedPeers === totalPeers) {
+            return 'strong';
+        }
+        else if (replicatedPeers > totalPeers / 2) {
+            return 'causal';
+        }
+        else {
+            return 'eventual';
+        }
+    }
+    /**
+     * Get replication targets for an index
+     */
+    getReplicationTargets(indexName) {
+        const state = this.replicationStates.get(indexName);
+        if (!state)
+            return [];
+        return Array.from(this.peerStates.keys()).filter((peerId) => peerId !== this.localPeerId && !state.replicatedPeers.has(peerId));
+    }
+    /**
+     * Detect version conflicts
+     */
+    detectConflicts(indexName) {
+        const state = this.replicationStates.get(indexName);
+        if (!state)
+            return [];
+        const conflicts = [];
+        for (const [peerId, peerVersion] of Object.entries(state.peerVersions)) {
+            if (this.isConcurrent(state.localVersion, peerVersion)) {
+                conflicts.push({
+                    indexName,
+                    localVersion: state.localVersion,
+                    remotePeer: peerId,
+                    remoteVersion: peerVersion,
+                });
+            }
+        }
+        return conflicts;
+    }
+    /**
+     * Merge versions using CRDT strategy
+     */
+    mergeVersions(indexName) {
+        const state = this.replicationStates.get(indexName);
+        if (!state)
+            return;
+        for (const peerVersion of Object.values(state.peerVersions)) {
+            this.mergeClocks(state.localVersion, peerVersion);
+        }
+    }
+    /**
+     * Set peer reachability
+     */
+    setPeerReachable(peerId, reachable) {
+        const peer = this.peerStates.get(peerId);
+        if (peer) {
+            peer.reachable = reachable;
+        }
+    }
+    /**
+     * Get overall sync status
+     */
+    getSyncStatus() {
+        const totalIndexes = this.replicationStates.size;
+        const fullyReplicated = Array.from(this.replicationStates.values()).filter((state) => state.replicatedPeers.size === this.peerStates.size).length;
+        const pendingOperations = Array.from(this.replicationStates.values()).reduce((sum, state) => sum + state.pendingSync.length, 0);
+        const unreachablePeers = Array.from(this.peerStates.values()).filter((p) => !p.reachable).length;
+        return {
+            totalIndexes,
+            fullyReplicated,
+            partiallyReplicated: totalIndexes - fullyReplicated,
+            pendingOperations,
+            unreachablePeers,
+        };
+    }
+    /**
+     * Vector clock utilities
+     */
+    isConcurrent(clock1, clock2) {
+        return !this.happensBefore(clock1, clock2) && !this.happensBefore(clock2, clock1);
+    }
+    happensBefore(clock1, clock2) {
+        let less = false;
+        for (const [node, timestamp] of Object.entries(clock1.clock)) {
+            const other = clock2.clock[node] ?? 0;
+            if (timestamp > other) {
+                return false;
+            }
+            if (timestamp < other) {
+                less = true;
+            }
+        }
+        return less;
+    }
+    mergeClocks(target, source) {
+        for (const [node, timestamp] of Object.entries(source.clock)) {
+            if (!target.clock[node] || target.clock[node] < timestamp) {
+                target.clock[node] = timestamp;
+            }
+        }
+    }
+}
+/**
+ * Synchronization coordinator for multi-node environments
+ */
+export class DistributedSyncCoordinator {
+    constructor(indexManager) {
+        this.syncInterval = null;
+        this.syncIntervalMs = 5000; // 5 seconds
+        this.indexManager = indexManager;
+    }
+    /**
+     * Start periodic synchronization
+     */
+    startSync(intervalMs = 5000) {
+        this.syncIntervalMs = intervalMs;
+        this.syncInterval = setInterval(() => {
+            this.performSync();
+        }, intervalMs);
+    }
+    /**
+     * Stop synchronization
+     */
+    stopSync() {
+        if (this.syncInterval) {
+            clearInterval(this.syncInterval);
+            this.syncInterval = null;
+        }
+    }
+    /**
+     * Perform synchronization cycle
+     */
+    performSync() {
+        const status = this.indexManager.getSyncStatus();
+        // Log sync status
+        if (status.pendingOperations > 0) {
+            console.debug(`[DistributedSync] Pending: ${status.pendingOperations}, Replicated: ${status.fullyReplicated}/${status.totalIndexes}`);
+        }
+        // Detect conflicts
+        // For each index, check for conflicts and attempt resolution
+    }
+    /**
+     * Explicitly sync a specific index
+     */
+    syncIndex(indexName) {
+        const status = this.indexManager.getReplicationStatus(indexName);
+        if (status && status.pendingSyncs > 0) {
+            console.debug(`[DistributedSync] Syncing ${indexName} to ${status.totalPeers - status.replicatedTo} peers`);
+        }
+    }
+}

package/dist/flowspec.d.ts

@@ -55,6 +55,10 @@ export interface FlowMigrationOperation {
     safety: 'safe' | 'requires_transform' | 'destructive';
     detail: string;
 }
+import type { ApplicationManifest } from './application-manifest.js';
+/** FlowSpec is a portable source format; the returned Rust manifest is authoritative only after server validation. */
+export declare function flowSpecToManifest(spec: FlowSpec, tenantId: string, applicationId: string): ApplicationManifest;
+export declare function manifestToFlowSpec(manifest: ApplicationManifest): FlowSpec;
 export declare function parseFlowSpec(source: string): FlowSpec;
 export declare function validateFlowSpec(spec: FlowSpec): FlowDiagnostic[];
 export declare function formatFlowSpec(spec: FlowSpec): string;

package/dist/flowspec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowspec.d.ts","sourceRoot":"","sources":["../src/flowspec.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE;AAC5E,MAAM,WAAW,SAAS;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE;AAC7E,MAAM,WAAW,cAAc;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE;AAC3F,MAAM,WAAW,SAAS;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE;AACjE,MAAM,WAAW,QAAS,SAAQ,SAAS;CAAG;AAC9C,MAAM,WAAW,YAAY;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,QAAQ,EAAE,CAAA;CAAE;AACrF,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE;AACpE,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,CAAC,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,YAAY,EAAE,SAAS,EAAE,CAAC;IAC1B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,SAAS,EAAE,SAAS,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAAG,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE;AACjG,MAAM,WAAW,YAAY;IAAG,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE;AACvF,MAAM,WAAW,sBAAsB;IAAG,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAyFpK,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAA4C;AAEnG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,EAAE,CAWjE;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAUrD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,YAAY,CAQ5E;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,sBAAsB,EAAE,CAsBjG;AAED,wBAAgB,aAAa,CAAC,GAAG,SAAU,GAAG,QAAQ,CAAyI"}
+{"version":3,"file":"flowspec.d.ts","sourceRoot":"","sources":["../src/flowspec.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE;AAC5E,MAAM,WAAW,SAAS;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE;AAC7E,MAAM,WAAW,cAAc;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE;AAC3F,MAAM,WAAW,SAAS;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE;AACjE,MAAM,WAAW,QAAS,SAAQ,SAAS;CAAG;AAC9C,MAAM,WAAW,YAAY;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,QAAQ,EAAE,CAAA;CAAE;AACrF,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE;AACpE,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,CAAC,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,YAAY,EAAE,SAAS,EAAE,CAAC;IAC1B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,SAAS,EAAE,SAAS,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAAG,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE;AACjG,MAAM,WAAW,YAAY;IAAG,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE;AACvF,MAAM,WAAW,sBAAsB;IAAG,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAEpK,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,sHAAsH;AACtH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,mBAAmB,CAG/G;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,QAAQ,CAE1E;AAyFD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAA4C;AAEnG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,EAAE,CAWjE;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAUrD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,YAAY,CAQ5E;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,sBAAsB,EAAE,CAsBjG;AAED,wBAAgB,aAAa,CAAC,GAAG,SAAU,GAAG,QAAQ,CAAyI"}

package/dist/flowspec.js

@@ -1,3 +1,11 @@
+/** FlowSpec is a portable source format; the returned Rust manifest is authoritative only after server validation. */
+export function flowSpecToManifest(spec, tenantId, applicationId) {
+    const capabilities = spec.capabilities.map(value => ({ name: value.name }));
+    return { application_id: applicationId, tenant_id: tenantId, schema: 1, metadata: { name: spec.app, labels: {} }, collections: spec.collections.map(value => ({ name: value.name, fields: value.fields.map(field => ({ name: field.name, type: field.type, required: !field.optional })) })), indexes: spec.collections.flatMap(collection => collection.indexes.map(index => ({ name: index.name, collection: collection.name, fields: [index.expression], unique: index.kind === 'unique' }))), references: [], queries: [], actions: [], workflows: spec.workflows.map(value => ({ name: value.name, steps: value.steps.map(step => ({ name: step.name })) })), triggers: spec.triggers.map((value, index) => ({ name: `trigger-${index + 1}`, event: value.event, workflow: spec.workflows[0]?.name || '' })), schedules: spec.schedules.map(value => ({ name: value.name, expression: value.statements[0] || '', workflow: spec.workflows[0]?.name || '' })), agents: spec.agents.map(value => ({ name: value.name, capabilities: capabilities.map(capability => capability.name).filter(name => value.statements.some(statement => statement.includes(name))) })), capabilities, connections: [], policies: spec.policies.map(value => ({ name: value.name, resource: value.statements[0] || 'application', capabilities: [] })), ui: { routes: [], bindings: [], forms: [], dashboards: [] }, environments: ['development', 'preview', 'staging', 'production'].map(name => ({ name, configuration: {} })), artifacts: [], deployment: { environments: ['development', 'preview', 'staging', 'production'] }, runtime: { contract: 1, minimum_engine: '0.2.0', maximum_engine_exclusive: '2.0.0' } };
+}
+export function manifestToFlowSpec(manifest) {
+    return { version: 1, app: manifest.metadata.name, collections: manifest.collections.map(value => ({ name: value.name, fields: value.fields.map(field => ({ name: field.name, type: field.type, optional: !field.required })), indexes: manifest.indexes.filter(index => index.collection === value.name).map(index => ({ name: index.name, kind: index.unique ? 'unique' : 'index', expression: index.fields.join(', ') })) })), capabilities: manifest.capabilities.map(value => ({ name: value.name, statements: value.provider ? [`provider ${value.provider}`] : [] })), agents: manifest.agents.map(value => ({ name: value.name, statements: value.capabilities.map(capability => `capability ${capability}`) })), workflows: manifest.workflows.map(value => ({ name: value.name, parameters: '', steps: value.steps.map(step => ({ name: step.name, statements: step.capability ? [`capability ${step.capability}`] : [] })) })), triggers: manifest.triggers.map(value => ({ event: value.event, statements: [`run ${value.workflow}`] })), policies: manifest.policies.map(value => ({ name: value.name, statements: [value.resource, ...value.capabilities] })), schedules: manifest.schedules.map(value => ({ name: value.name, statements: [value.expression, `run ${value.workflow}`] })) };
+}
 function lex(source) {
     const tokens = [];
     let line = 1;

package/dist/http-client.d.ts

@@ -0,0 +1,35 @@
+/**
+ * FeltDB HTTP Client - Lightweight client for remote FeltDB servers
+ *
+ * Provides a simple interface for connecting to and querying remote FeltDB instances.
+ * For applications that only need HTTP access without the full core framework.
+ */
+export interface ClientOptions {
+    url: string;
+    token: string;
+}
+export interface RemoteRecord<T> {
+    id: string;
+    key: string;
+    value: T;
+    version_ms: number;
+}
+export declare class FeltDBClient {
+    private readonly url;
+    private readonly token;
+    constructor(options: ClientOptions);
+    private headers;
+    private request;
+    runtime(): Promise<Record<string, unknown>>;
+    list<T>(collection: string): Promise<Array<RemoteRecord<T>>>;
+    get<T>(collection: string, id: string | number): Promise<RemoteRecord<T>>;
+    insert<T extends object>(collection: string, value: T, id?: string | number): Promise<RemoteRecord<T>>;
+    update<T extends object>(collection: string, id: string | number, changes: Partial<T>): Promise<RemoteRecord<T>>;
+    delete(collection: string, id: string | number): Promise<void>;
+    getInfo(): {
+        runtime: 'remote';
+        url: string;
+    };
+}
+export declare function createClient(options: ClientOptions): FeltDBClient;
+//# sourceMappingURL=http-client.d.ts.map

package/dist/http-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["../src/http-client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,CAAC,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,OAAO,EAAE,aAAa;IAMlC,OAAO,CAAC,OAAO;YAQD,OAAO;IAgBrB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAI3C,IAAI,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAI5D,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAIzE,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAOtG,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAOhH,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9D,OAAO,IAAI;QAAE,OAAO,EAAE,QAAQ,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE;CAG9C;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAEjE"}

package/dist/http-client.js

@@ -0,0 +1,70 @@
+/**
+ * FeltDB HTTP Client - Lightweight client for remote FeltDB servers
+ *
+ * Provides a simple interface for connecting to and querying remote FeltDB instances.
+ * For applications that only need HTTP access without the full core framework.
+ */
+export class FeltDBClient {
+    constructor(options) {
+        if (!options.url || !options.token)
+            throw new Error('FeltDBClient requires url and token');
+        this.url = options.url.replace(/\/$/, '');
+        this.token = options.token;
+    }
+    headers(json = false) {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            'FeltDB-Protocol': '1',
+            ...(json ? { 'Content-Type': 'application/json' } : {}),
+        };
+    }
+    async request(path, init = {}) {
+        const response = await fetch(`${this.url}${path}`, {
+            ...init,
+            headers: { ...this.headers(init.body !== undefined), ...init.headers },
+        });
+        if (!response.ok) {
+            let message = `FeltDB request failed: HTTP ${response.status}`;
+            try {
+                const body = await response.json();
+                if (body.error)
+                    message = body.error;
+            }
+            catch { /* non-JSON error */ }
+            throw new Error(message);
+        }
+        return (response.status === 204 ? undefined : response.json());
+    }
+    runtime() {
+        return this.request('/runtime');
+    }
+    list(collection) {
+        return this.request(`/collections/${encodeURIComponent(collection)}`);
+    }
+    get(collection, id) {
+        return this.request(`/collections/${encodeURIComponent(collection)}/${encodeURIComponent(String(id))}`);
+    }
+    insert(collection, value, id) {
+        return this.request(`/collections/${encodeURIComponent(collection)}`, {
+            method: 'POST',
+            body: JSON.stringify(id === undefined ? value : { ...value, id }),
+        });
+    }
+    update(collection, id, changes) {
+        return this.request(`/collections/${encodeURIComponent(collection)}/${encodeURIComponent(String(id))}`, {
+            method: 'PATCH',
+            body: JSON.stringify(changes),
+        });
+    }
+    delete(collection, id) {
+        return this.request(`/collections/${encodeURIComponent(collection)}/${encodeURIComponent(String(id))}`, {
+            method: 'DELETE',
+        });
+    }
+    getInfo() {
+        return { runtime: 'remote', url: this.url };
+    }
+}
+export function createClient(options) {
+    return new FeltDBClient(options);
+}

package/dist/identity.d.ts

@@ -0,0 +1,40 @@
+export type IdentityStatus = 'unverified' | 'active' | 'suspended' | 'locked' | 'revoked';
+export interface Identity {
+    identityId: string;
+    subjectId: string;
+    provider: string;
+    providerSubject: string;
+    email?: string;
+    displayName?: string;
+    status: IdentityStatus;
+    createdAt: number;
+    metadata: unknown;
+}
+export interface IdentitySession {
+    sessionId: string;
+    identityId: string;
+    subjectId: string;
+    issuedAt: number;
+    expiresAt: number;
+    lastSeenAt: number;
+    device?: string;
+    provider: string;
+    status: string;
+    revocationReason?: string;
+}
+export declare class IdentityClient {
+    private readonly request;
+    constructor(request: (path: string, init?: RequestInit) => Promise<any>);
+    me(): Promise<any>;
+    sessions(): Promise<any>;
+    revokeSession(id: string): Promise<any>;
+    revokeAll(): Promise<any>;
+    normalize(input: {
+        provider: string;
+        providerSubject: string;
+        email?: string;
+        displayName?: string;
+        metadata?: unknown;
+    }): Promise<any>;
+}
+//# sourceMappingURL=identity.d.ts.map

package/dist/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,YAAY,GAAC,QAAQ,GAAC,WAAW,GAAC,QAAQ,GAAC,SAAS,CAAC;AAClF,MAAM,WAAW,QAAQ;IAAG,UAAU,EAAC,MAAM,CAAC;IAAC,SAAS,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,MAAM,CAAC;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,KAAK,CAAC,EAAC,MAAM,CAAC;IAAC,WAAW,CAAC,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,cAAc,CAAC;IAAC,SAAS,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,OAAO,CAAA;CAAE;AACzM,MAAM,WAAW,eAAe;IAAG,SAAS,EAAC,MAAM,CAAC;IAAC,UAAU,EAAC,MAAM,CAAC;IAAC,SAAS,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,MAAM,CAAC;IAAC,SAAS,EAAC,MAAM,CAAC;IAAC,UAAU,EAAC,MAAM,CAAC;IAAC,MAAM,CAAC,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAC,MAAM,CAAA;CAAE;AAC1N,qBAAa,cAAc;IAAe,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAC,CAAC,IAAI,EAAC,MAAM,EAAC,IAAI,CAAC,EAAC,WAAW,KAAG,OAAO,CAAC,GAAG,CAAC;IAAI,EAAE;IAA2C,QAAQ;IAAiD,aAAa,CAAC,EAAE,EAAC,MAAM;IAAiG,SAAS;IAA4E,SAAS,CAAC,KAAK,EAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAA,eAAe,EAAC,MAAM,CAAC;QAAA,KAAK,CAAC,EAAC,MAAM,CAAC;QAAA,WAAW,CAAC,EAAC,MAAM,CAAC;QAAA,QAAQ,CAAC,EAAC,OAAO,CAAA;KAAC;CAAyI"}

package/dist/identity.js

@@ -0,0 +1,10 @@
+export class IdentityClient {
+    constructor(request) {
+        this.request = request;
+    }
+    me() { return this.request('/v1/identity/me'); }
+    sessions() { return this.request('/v1/identity/sessions'); }
+    revokeSession(id) { return this.request(`/v1/identity/sessions/${encodeURIComponent(id)}/revoke`, { method: 'POST' }); }
+    revokeAll() { return this.request('/v1/identity/sessions/revoke-all', { method: 'POST' }); }
+    normalize(input) { return this.request('/v1/identity/normalize', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(input) }); }
+}