create-feltdb 0.11.3 → 0.11.7

package/dist/server-source/crates/feltdb/tests/semantic_query_contract.rs

@@ -0,0 +1,363 @@
+//! Semantic query composition contract — boundary tests.
+//!
+//! `docs/reference/semantic-query.md` fixes the semantics a FeltDB query
+//! surface must honor when a semantic decision participates in a query. The
+//! bounded authority query implements it (`tests/semantic_query.rs` proves the
+//! page transformation; `e2e/semantic-query-composition.test.mjs` proves the
+//! managed surface). These tests pin the boundaries the contract draws around
+//! the rest of the crate: the canonical query has no semantic vocabulary but
+//! recognizes and refuses a semantic clause rather than dropping it, the
+//! decision transport stays record-scoped, runtime capabilities describe
+//! decisions rather than composition, the record-scoped primitive itself has
+//! no page boundary (the page boundary is `semantic_query`'s), and judgments
+//! stay beside application state. Each test names the section it guards.
+
+use feltdb::semantic_decision::{
+    decide_record, execute_decision_transport, DecisionDefinition, DecisionError, DecisionOptions,
+    DecisionRecordRef, DecisionRequest, DecisionResult, DecisionRuntime,
+    DecisionRuntimeCapabilities, DecisionRuntimeMetadata, DecisionTransportExecutionRequest,
+    DecisionTransportRuntime, DEFAULT_DECISION_COLLECTION,
+};
+use feltdb::state_contract::{query_hash, CanonicalQuery, QueryFilter};
+use feltdb::FeltDb;
+use serde_json::{json, Value};
+use std::collections::BTreeSet;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+
+fn memory_db(name: &str) -> FeltDb {
+    let path = std::env::temp_dir().join(format!(
+        "feltdb-semantic-query-contract-{name}-{}.log",
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("time")
+            .as_nanos()
+    ));
+    FeltDb::open(path).expect("db")
+}
+
+/// A runtime that answers `score` decisions from an `urgency` field and counts
+/// every invocation, so the tests can measure what reaches a provider.
+#[derive(Clone)]
+struct CountingRuntime {
+    invocations: Arc<AtomicUsize>,
+}
+
+impl CountingRuntime {
+    fn new() -> Self {
+        Self {
+            invocations: Arc::new(AtomicUsize::new(0)),
+        }
+    }
+
+    fn invocations(&self) -> usize {
+        self.invocations.load(Ordering::SeqCst)
+    }
+}
+
+impl DecisionRuntime for CountingRuntime {
+    fn metadata(&self) -> DecisionRuntimeMetadata {
+        DecisionRuntimeMetadata {
+            runtime: "deterministic".into(),
+            model: Some("deterministic-runtime".into()),
+            model_revision: Some("deterministic-v1".into()),
+            prompt_revision: Some("prompt-v1".into()),
+            execution_method: Some(feltdb::DecisionExecutionMethod::Logit),
+            decision_schema_revision: Some("semantic-decision-v1".into()),
+        }
+    }
+
+    fn decide(&self, request: &DecisionRequest) -> Result<DecisionResult, DecisionError> {
+        self.invocations.fetch_add(1, Ordering::SeqCst);
+        let urgency = request
+            .context()
+            .get("urgency")
+            .and_then(Value::as_str)
+            .unwrap_or("low")
+            .to_string();
+        let levels = ["low", "medium", "high"]
+            .into_iter()
+            .map(|level| feltdb::WeightedOption {
+                value: level.into(),
+                probability: if level == urgency { 0.9 } else { 0.05 },
+            })
+            .collect();
+        Ok(DecisionResult::Score {
+            selected: urgency,
+            levels,
+            option_mass: 0.9,
+            supporting_fields: vec!["urgency".into()],
+        })
+    }
+}
+
+fn urgency_definition() -> DecisionDefinition {
+    DecisionDefinition::Score {
+        question: "What is the urgency?".into(),
+        levels: vec!["low".into(), "medium".into(), "high".into()],
+    }
+}
+
+fn seed_tickets(db: &FeltDb, count: usize) {
+    for index in 0..count {
+        let urgency = ["low", "medium", "high"][index % 3];
+        db.insert(
+            &format!("tickets:t-{index}"),
+            json!({
+                "id": format!("t-{index}"),
+                "__version": 1,
+                "title": format!("Ticket {index}"),
+                "urgency": urgency,
+            }),
+        )
+        .expect("insert");
+    }
+}
+
+/// §7 / §11.6 — the canonical `QueryFilter` vocabulary has no semantic
+/// operator. A filter naming one is refused at deserialization, so no
+/// canonical query can currently express semantic filtering at all.
+#[test]
+fn canonical_query_filter_has_no_semantic_operator() {
+    let semantic = json!({
+        "operator": "semantic",
+        "field": "urgency",
+        "decision": { "kind": "binary", "predicate": "is urgent" },
+    });
+    let error = serde_json::from_value::<QueryFilter>(semantic).expect_err("no semantic operator");
+    assert!(
+        error.to_string().contains("semantic"),
+        "unexpected rejection reason: {error}"
+    );
+
+    // The deterministic vocabulary the contract composes with is intact.
+    let deterministic = serde_json::from_value::<QueryFilter>(json!({
+        "operator": "eq",
+        "field": "urgency",
+        "value": "high",
+    }))
+    .expect("deterministic filter");
+    assert!(matches!(deterministic, QueryFilter::Eq { .. }));
+}
+
+/// §11.6 — the canonical query recognizes a semantic clause it does not
+/// compose. The clause is carried into the query rather than lost as an
+/// unknown key, so the query's identity changes with it and `execute_query`
+/// can refuse it with `SEMANTIC_UNSUPPORTED` (`state_contract` tests prove
+/// the refusal; `e2e/semantic-query-composition.test.mjs` proves it over
+/// `/v1/query`). The bounded authority query implements the same clause.
+#[test]
+fn canonical_query_recognizes_a_semantic_clause_it_does_not_compose() {
+    let plain = json!({
+        "collection": "tickets",
+        "filter": { "operator": "eq", "field": "urgency", "value": "high" },
+        "limit": 10,
+    });
+    let mut with_clause = plain.clone();
+    with_clause["semantic"] = json!({
+        "decision": { "kind": "binary", "predicate": "is urgent" },
+        "filter": { "is": true },
+    });
+
+    let plain: CanonicalQuery = serde_json::from_value(plain).expect("plain query");
+    let with_clause: CanonicalQuery =
+        serde_json::from_value(with_clause).expect("the clause is carried, not refused here");
+
+    assert!(plain.semantic.is_none());
+    assert!(with_clause.semantic.is_some());
+    assert_ne!(
+        query_hash(&plain).expect("hash"),
+        query_hash(&with_clause).expect("hash"),
+        "the semantic clause is part of query identity"
+    );
+    // The same clause is exactly what the bounded authority query accepts.
+    let clause: feltdb::SemanticQueryClause =
+        serde_json::from_value(with_clause.semantic.clone().unwrap()).expect("bounded clause");
+    feltdb::validate_semantic_clause(&clause).expect("valid for the bounded query");
+}
+
+/// §3 / §5 — the semantic-decision transport addresses exactly one durable
+/// record. There is no candidate-set, page, or collection-level target: a
+/// target without a record id does not deserialize, and the transport refuses
+/// both "no target" and "two targets".
+#[test]
+fn decision_transport_targets_exactly_one_durable_record() {
+    let collection_only = serde_json::from_value::<DecisionRecordRef>(json!({
+        "collection": "tickets",
+    }))
+    .expect_err("a collection is not a decision target");
+    assert!(
+        collection_only.to_string().contains("record_id"),
+        "unexpected rejection reason: {collection_only}"
+    );
+
+    let db = memory_db("transport-target");
+    seed_tickets(&db, 1);
+    let runtime = DecisionTransportRuntime::Recording {
+        metadata: CountingRuntime::new().metadata(),
+        result: DecisionResult::Score {
+            selected: "low".into(),
+            levels: vec![],
+            option_mass: 0.9,
+            supporting_fields: vec![],
+        },
+    };
+    let request = |target: Option<DecisionRecordRef>, context: Option<Value>| {
+        DecisionTransportExecutionRequest {
+            target,
+            context,
+            definition: urgency_definition(),
+            options: DecisionOptions::default(),
+            authorization: None,
+            runtime: runtime.clone(),
+        }
+    };
+
+    let neither = execute_decision_transport(&db, &request(None, None)).expect_err("no target");
+    assert_eq!(neither.code, "DECISION_INVALID_RESULT");
+
+    let both = execute_decision_transport(
+        &db,
+        &request(
+            Some(DecisionRecordRef {
+                collection: "tickets".into(),
+                record_id: "t-0".into(),
+            }),
+            Some(json!({ "urgency": "high" })),
+        ),
+    )
+    .expect_err("two targets");
+    assert_eq!(both.code, "DECISION_INVALID_RESULT");
+}
+
+/// §14 — runtime capabilities describe decision kinds and batching only. No
+/// capability speaks about candidate sets, ordering, filtering, or cursors,
+/// so a runtime cannot currently advertise query composition and a query
+/// surface cannot currently negotiate it.
+#[test]
+fn runtime_capabilities_declare_no_query_composition() {
+    let capabilities =
+        serde_json::to_value(DecisionRuntimeCapabilities::default()).expect("capabilities");
+    let declared = capabilities
+        .as_object()
+        .expect("object")
+        .keys()
+        .cloned()
+        .collect::<BTreeSet<_>>();
+    let expected = [
+        "batch",
+        "binary",
+        "choice",
+        "execution_methods",
+        "probability_distribution",
+        "score",
+    ]
+    .into_iter()
+    .map(String::from)
+    .collect::<BTreeSet<_>>();
+    assert_eq!(declared, expected);
+}
+
+/// §8 / §13 — the record-scoped primitive has no page boundary of its own:
+/// evaluating N records is N calls, nothing in `semantic_decision` filters or
+/// orders judgments, and results come back in request order. The page boundary,
+/// filtering, and ordering belong to `semantic_query`, which consumes this
+/// primitive and never re-implements it. Reuse is the primitive's own bound:
+/// a second pass costs nothing.
+#[test]
+fn record_scoped_evaluation_has_no_page_boundary_and_no_ordering() {
+    let db = memory_db("page-boundary");
+    seed_tickets(&db, 6);
+    let runtime = CountingRuntime::new();
+    let ids = (0..6).map(|index| format!("t-{index}")).collect::<Vec<_>>();
+
+    let first_pass = ids
+        .iter()
+        .map(|id| {
+            decide_record(
+                &db,
+                &DecisionRecordRef {
+                    collection: "tickets".into(),
+                    record_id: id.clone(),
+                },
+                &urgency_definition(),
+                &runtime,
+                &DecisionOptions::default(),
+                None,
+            )
+            .expect("evaluation")
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(runtime.invocations(), ids.len());
+    assert!(first_pass.iter().all(|evaluation| !evaluation.cached));
+
+    let selected = first_pass
+        .iter()
+        .map(|evaluation| match &evaluation.result {
+            DecisionResult::Score { selected, .. } => selected.clone(),
+            other => panic!("unexpected result {other:?}"),
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(selected, ["low", "medium", "high", "low", "medium", "high"]);
+    let mut ordered = selected.clone();
+    ordered.sort_by_key(|level| ["low", "medium", "high"].iter().position(|l| l == level));
+    assert_ne!(
+        selected, ordered,
+        "results come back in request order; nothing in the crate ranks them"
+    );
+
+    for id in &ids {
+        let again = decide_record(
+            &db,
+            &DecisionRecordRef {
+                collection: "tickets".into(),
+                record_id: id.clone(),
+            },
+            &urgency_definition(),
+            &runtime,
+            &DecisionOptions::default(),
+            None,
+        )
+        .expect("reuse");
+        assert!(again.cached);
+        assert_eq!(again.provenance.source, "cache");
+    }
+    assert_eq!(runtime.invocations(), ids.len());
+}
+
+/// §6 — a judgment is durable derived state in the decision collection. The
+/// application record it judged is untouched: same value, same version. A
+/// semantic query must keep this separation; it may write judgments and
+/// nothing else.
+#[test]
+fn judgments_live_beside_application_state_and_never_inside_it() {
+    let db = memory_db("derived-judgment");
+    seed_tickets(&db, 1);
+    let before: Value = db.get("tickets:t-0").expect("get").expect("record");
+
+    let evaluation = decide_record(
+        &db,
+        &DecisionRecordRef {
+            collection: "tickets".into(),
+            record_id: "t-0".into(),
+        },
+        &urgency_definition(),
+        &CountingRuntime::new(),
+        &DecisionOptions::default(),
+        None,
+    )
+    .expect("evaluation");
+
+    let after: Value = db.get("tickets:t-0").expect("get").expect("record");
+    assert_eq!(before, after, "the judged record is not modified");
+
+    let judgments = db
+        .capability(DEFAULT_DECISION_COLLECTION)
+        .find(|_: &feltdb::DecisionJudgmentRecord| true)
+        .expect("judgments");
+    assert_eq!(judgments.len(), 1);
+    assert_eq!(judgments[0].id, evaluation.provenance.cache_key);
+    assert_eq!(judgments[0].collection, "tickets");
+    assert_eq!(judgments[0].record_id, "t-0");
+    assert_eq!(judgments[0].state.reference, "tickets:t-0");
+}

package/dist/server-source/crates/feltdb-server/src/app_state.rs

@@ -87,6 +87,11 @@ pub struct AppState {
     pub mesh: Arc<std::sync::Mutex<WorkerMeshStore>>,
     pub readiness_probe: Arc<PathBuf>,
     pub bounded_query_cursors: Arc<std::sync::Mutex<HashMap<String, BoundedQueryCursor>>>,
+    /// The deployment's semantic runtime binding for bounded semantic query
+    /// composition, or `None` when the deployment configures no runtime. A
+    /// query never names its runtime; this binding's identity is part of
+    /// every judgment the query stage produces or reuses.
+    pub semantic_runtime: Option<Arc<dyn feltdb::DecisionRuntime + Send + Sync>>,
     /// Bounds how many requests may be in flight at once.
     ///
     /// Every read and write serializes on one lock inside the database, so

package/dist/server-source/crates/feltdb-server/src/main.rs

@@ -7303,6 +7303,7 @@ async fn run_runtime_query(
         group_by: vec![],
         aggregates: vec![],
         references: vec![],
+        semantic: None,
     };
     let context = feltdb::state_contract::begin_query_read(
         &state.db,
@@ -7555,6 +7556,7 @@ fn state_contract_error(error: feltdb::state_contract::StateFailure) -> ApiError
         "AUTHORIZATION_DENIED" => StatusCode::FORBIDDEN,
         "PRECONDITION_FAILED" | "CONFLICT" | "IDEMPOTENCY_CONFLICT" => StatusCode::CONFLICT,
         "UNKNOWN_COLLECTION" => StatusCode::NOT_FOUND,
+        "SEMANTIC_UNSUPPORTED" => StatusCode::NOT_IMPLEMENTED,
         "STORAGE_FAILURE" | "STATE_UNAVAILABLE" => StatusCode::SERVICE_UNAVAILABLE,
         _ => StatusCode::UNPROCESSABLE_ENTITY,
     };
@@ -8675,6 +8677,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         mesh: Arc::new(std::sync::Mutex::new(mesh_store)),
         readiness_probe: Arc::new(readiness_probe),
         bounded_query_cursors: Arc::new(std::sync::Mutex::new(HashMap::new())),
+        semantic_runtime: configured_semantic_runtime()?,
     };
     start_peer_sessions(&state, &config)?;
     start_membership_recovery(&state);
@@ -12745,7 +12748,7 @@ async fn get_revision(State(state): State<AppState>) -> Result<Json<RevisionResp
     }))
 }
 
-const MAX_BOUNDED_QUERY_LIMIT: usize = 500;
+const MAX_BOUNDED_QUERY_LIMIT: usize = 1_000;
 const BOUNDED_CURSOR_TTL_SECONDS: u64 = 300;
 
 #[derive(Clone, Deserialize, Serialize)]
@@ -12759,6 +12762,11 @@ struct BoundedQueryRequest {
     limit: usize,
     #[serde(default)]
     cursor: Option<String>,
+    /// Semantic composition over the deterministic page, per
+    /// `docs/reference/semantic-query.md`. Bound into the request hash so a
+    /// continuation cursor is valid only under the clause it was issued for.
+    #[serde(default)]
+    semantic: Option<feltdb::SemanticQueryClause>,
 }
 
 #[derive(Clone, Deserialize, Serialize)]
@@ -12781,6 +12789,63 @@ struct BoundedQueryPage {
     #[serde(skip_serializing_if = "Option::is_none")]
     next_cursor: Option<String>,
     exhausted: bool,
+    /// Present exactly when the request carried a semantic clause. Its
+    /// `annotations` align with `records`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    semantic: Option<BoundedQuerySemanticResult>,
+}
+
+#[derive(Serialize)]
+struct BoundedQuerySemanticResult {
+    complete: bool,
+    stage: feltdb::SemanticStageSummary,
+    annotations: Vec<Option<feltdb::SemanticAnnotation>>,
+    unevaluated: Vec<feltdb::SemanticUnevaluated>,
+}
+
+/// The deployment's semantic runtime binding, from `FELTDB_SEMANTIC_RUNTIME`.
+///
+/// The variable names a JSON file in the semantic-decision transport's runtime
+/// shape (`{"kind": "deterministic", "metadata": {...}, "responses": {...}}`).
+/// A deployment that sets nothing has no binding, and every semantic query
+/// fails with `SEMANTIC_PROVIDER_UNAVAILABLE` rather than answering the
+/// deterministic part as if the clause had been honored. A file that cannot be
+/// read or parsed is a startup failure: a misconfigured binding must not look
+/// like an unconfigured one.
+fn configured_semantic_runtime(
+) -> Result<Option<Arc<dyn feltdb::DecisionRuntime + Send + Sync>>, String> {
+    let Ok(path) = std::env::var("FELTDB_SEMANTIC_RUNTIME") else {
+        return Ok(None);
+    };
+    let source = std::fs::read_to_string(&path)
+        .map_err(|error| format!("FELTDB_SEMANTIC_RUNTIME {path} is unreadable: {error}"))?;
+    let runtime: feltdb::DecisionTransportRuntime =
+        serde_json::from_str(&source).map_err(|error| {
+            format!("FELTDB_SEMANTIC_RUNTIME {path} is not a runtime binding: {error}")
+        })?;
+    feltdb::configured_decision_runtime(&runtime)
+        .map(Some)
+        .map_err(|error| format!("FELTDB_SEMANTIC_RUNTIME {path} is refused: {error}"))
+}
+
+fn semantic_query_error(error: feltdb::SemanticQueryError) -> ApiError {
+    let status = match error.code.as_str() {
+        "INVALID_QUERY" | "INVALID_CURSOR" => StatusCode::UNPROCESSABLE_ENTITY,
+        "SEMANTIC_PROVIDER_UNAVAILABLE" | "DECISION_STORAGE_ERROR" => {
+            StatusCode::SERVICE_UNAVAILABLE
+        }
+        "SEMANTIC_UNSUPPORTED" => StatusCode::NOT_IMPLEMENTED,
+        "SEMANTIC_INVALID_RESULT" => StatusCode::BAD_GATEWAY,
+        _ => StatusCode::BAD_REQUEST,
+    };
+    ApiError::structured(
+        status,
+        json!({
+            "code": error.code,
+            "message": error.message,
+            "http_status": status.as_u16(),
+        }),
+    )
 }
 
 fn bounded_query_error(code: &str, message: impl Into<String>) -> ApiError {
@@ -12794,11 +12859,15 @@ fn bounded_query_error(code: &str, message: impl Into<String>) -> ApiError {
 }
 
 fn bounded_query_hash(request: &BoundedQueryRequest) -> Result<String, ApiError> {
+    // The semantic clause is part of the request a cursor is bound to, so a
+    // continuation presented under a different clause is `INVALID_CURSOR`. The
+    // clause's identity, never its results, enters the hash.
     let context = json!({
         "collection": request.collection,
         "where": request.conditions,
         "orderBy": request.order_by,
         "limit": request.limit,
+        "semantic": request.semantic.as_ref().map(feltdb::semantic_clause_hash),
     });
     let bytes = serde_json::to_vec(&context)
         .map_err(|error| bounded_query_error("INVALID_QUERY", error.to_string()))?;
@@ -13058,10 +13127,15 @@ async fn execute_bounded_query(
     State(state): State<AppState>,
     Extension(principal): Extension<Principal>,
     headers: HeaderMap,
-    Json(request): Json<BoundedQueryRequest>,
+    Json(request): Json<Value>,
 ) -> Result<Json<BoundedQueryPage>, ApiError> {
     let _handler =
         feltdb::workload_diagnostics::span(feltdb::workload_diagnostics::Phase::HandlerBody);
+    // A request this surface cannot represent — including a semantic clause
+    // with keys the contract does not define — is a structured `INVALID_QUERY`,
+    // so a client can tell a refused clause from a transport failure.
+    let request: BoundedQueryRequest = serde_json::from_value(request)
+        .map_err(|error| bounded_query_error("INVALID_QUERY", error.to_string()))?;
     let execution = bounded_query_execution(&headers)?;
     validate_segment(&request.collection)?;
     if request.limit == 0 || request.limit > MAX_BOUNDED_QUERY_LIMIT {
@@ -13100,6 +13174,10 @@ async fn execute_bounded_query(
             ));
         }
     }
+    // A malformed semantic clause fails before any deterministic work runs.
+    if let Some(clause) = &request.semantic {
+        feltdb::validate_semantic_clause(clause).map_err(semantic_query_error)?;
+    }
     let hash = bounded_query_hash(&request)?;
     let (records, position) = if let Some(token) = &request.cursor {
         let cursor = state
@@ -13187,7 +13265,7 @@ async fn execute_bounded_query(
             &state,
             BoundedQueryCursor {
                 query_hash: hash,
-                principal_key_id: principal.key_id,
+                principal_key_id: principal.key_id.clone(),
                 namespace: state.namespace.to_string(),
                 records: records.clone(),
                 position: end,
@@ -13197,10 +13275,80 @@ async fn execute_bounded_query(
     } else {
         None
     };
+    // The semantic stage transforms exactly this page. It runs after the
+    // deterministic cursor is issued because continuation is by deterministic
+    // position: the page may return fewer records than `limit` and still not
+    // be exhausted.
+    let semantic = match &request.semantic {
+        None => None,
+        Some(clause) => {
+            let candidates = page
+                .iter()
+                .map(|record| feltdb::SemanticCandidate {
+                    record_id: record
+                        .get("recordId")
+                        .and_then(Value::as_str)
+                        .unwrap_or_default()
+                        .to_string(),
+                    record: record.clone(),
+                })
+                .collect();
+            let composed = feltdb::compose_semantic_page(
+                &state.db,
+                &request.collection,
+                candidates,
+                clause,
+                state
+                    .semantic_runtime
+                    .as_deref()
+                    .map(|runtime| runtime as &dyn feltdb::DecisionRuntime),
+                clause.authorization.as_ref().map(|authorization| {
+                    let requested = authorization.principal.as_ref();
+                    feltdb::DecisionPrincipal {
+                        subject: decision_subject(&principal),
+                        tenant_id: requested
+                            .map(|value| value.tenant_id.clone())
+                            .unwrap_or_default(),
+                        application_id: requested
+                            .map(|value| value.application_id.clone())
+                            .unwrap_or_default(),
+                        capability: "state:read".into(),
+                    }
+                }),
+            )
+            .map_err(semantic_query_error)?;
+            audit(
+                &state,
+                &principal.key_id,
+                "semantic_query.compose",
+                &format!("{}@{}", request.collection, composed.stage.definition_hash),
+                if composed.complete {
+                    "complete"
+                } else {
+                    "incomplete"
+                },
+                200,
+            );
+            Some(composed)
+        }
+    };
+    let (page, semantic) = match semantic {
+        None => (page, None),
+        Some(composed) => (
+            composed.records,
+            Some(BoundedQuerySemanticResult {
+                complete: composed.complete,
+                stage: composed.stage,
+                annotations: composed.annotations,
+                unevaluated: composed.unevaluated,
+            }),
+        ),
+    };
     Ok(Json(BoundedQueryPage {
         records: page,
         exhausted: next_cursor.is_none(),
         next_cursor,
+        semantic,
     }))
 }
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "create-feltdb",
   "private": false,
   "description": "Create a new FeltDB application with one command",
-  "version": "0.11.3",
+  "version": "0.11.7",
   "license": "MIT",
   "bin": {
     "create-feltdb": "bin/create-feltdb.js"