@feltdb/core 0.12.1 → 0.13.0

package/dist/composition.js

@@ -1,5 +1,5 @@
 import { FeltDBErrorCode, FeltDBServiceError } from './error-codes.js';
-import { AtomicTransactionError, conditionalRefusal } from './transaction.js';
+import { AtomicTransactionError, TransactionIdConflictError, conditionalRefusal } from './transaction.js';
 import { FELTDB_INTENT_COLLECTION, FELTDB_INTENT_EVENT_COLLECTION } from './intent.js';
 import { FELTDB_PROPOSAL_EVENT_COLLECTION, PROPOSAL_TRANSITIONS } from './proposal.js';
 import { FELTDB_COMPOSITION_COLLECTION, FELTDB_COMPOSITION_CONTRACT_COLLECTION, FELTDB_COMPOSITION_TOPOLOGY_COLLECTION, FELTDB_COMPOSITION_VERSION_COLLECTION, FELTDB_STATE_ATTRIBUTION_COLLECTION, FELTDB_STATE_CHANGE_COLLECTION, FELTDB_STATE_DEPENDENCY_COLLECTION, FELTDB_STATE_IMPACT_COLLECTION, FELTDB_STATE_OBSERVATION_COLLECTION, FELTDB_STATE_OWNERSHIP_COLLECTION, FELTDB_STATE_PROPOSAL_COLLECTION, canonicalDigest, changedFields, computeImpactSurface, consumerUri, emptyImpactReads, impactReadSet, impactSurfaceDigest, parseStateUri, recordValue, recordVersion, redactImpactSurface, stateUri, } from './state-impact.js';
@@ -1181,6 +1181,16 @@ export class CompositionConsumer {
             });
         }
         catch (error) {
+            // `apply_<proposal id>` names the application of one proposal. If the
+            // authority already holds that id with different contents, another
+            // attempt applied this proposal first and its recorded facts -- when it
+            // was applied, under which decisions -- are its own. This call applied
+            // nothing, and is not a stale read of state, so no refusal is recorded
+            // against the proposal.
+            if (error instanceof TransactionIdConflictError) {
+                throw fail(`State proposal ${proposalId} was already applied by another attempt (transaction ${transactionId} is committed with different contents). `
+                    + 'Nothing was applied by this call.', FeltDBErrorCode.CONFLICT);
+            }
             const refusal = conditionalRefusal(error);
             const lostRace = refusal.conflict
                 || (error instanceof AtomicTransactionError && /conflict|PRECONDITION_FAILED/i.test(`${error.name} ${error.code ?? ''}`))

package/dist/create/build-identity.json

@@ -1,8 +1,13 @@
 {
-  "schema": "feltdb.core-build-identity.v1",
+  "schema": "feltdb.build-identity.v2",
   "package": "create-feltdb",
-  "version": "0.12.1",
-  "source_digest": "sha256:95a6ebf48be2a6be56fad60c24a10b62d93878857e728448913d9bc243e8ce3a",
+  "version": "0.13.0",
+  "git": {
+    "sha1": "b67312f73ea647ffea6f87337303c170d40d541d",
+    "dirty": false
+  },
+  "path_in_vcs": "tools/create-feltdb",
+  "source_digest": "sha256:7435af3423598673fcce76eb77444ee1e160f39f3fd83a0a788517e315bd3444",
   "inputs": [
     "Cargo.lock",
     "Cargo.toml",
@@ -15,5 +20,9 @@
     "tools/cli",
     "tools/create-feltdb"
   ],
-  "files": 731
+  "files": 776,
+  "build": {
+    "command": "npm run build",
+    "node": "v24.9.0"
+  }
 }

package/dist/create/cli.js

@@ -11,15 +11,18 @@ import { spawn, spawnSync } from 'child_process';
 import { createProject } from './create.js';
 import { FELTDB_PACKAGE_VERSION } from './package-versions.js';
 import { configureManagedAccount, finalizeManagedProvisioning } from './managed-account.js';
+import { RUNTIME_CHOICES, agentsIncluded, describeSetup } from './setup-summary.js';
 import { localFeltdbExecutable } from './development-handoff.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function parseArgs(args) {
     const options = {
         runtime: 'browser',
         framework: 'react',
-        distributed: true,
+        // Distribution and the browser AI builder add services and downloads a
+        // first project does not need; each is one flag away.
+        distributed: false,
         agents: true,
-        webllm: true,
+        webllm: false,
         capabilities: 'search',
     };
     for (let i = 0; i < args.length; i++) {
@@ -42,6 +45,9 @@ function parseArgs(args) {
             case '--framework':
                 options.framework = args[++i];
                 break;
+            case '--distributed':
+                options.distributed = true;
+                break;
             case '--no-distributed':
                 options.distributed = false;
                 break;
@@ -164,29 +170,28 @@ async function promptForOptions(defaults) {
         { label: 'Yes', value: true },
         { label: 'No', value: false },
     ];
-    return {
-        runtime: await select('Where should FeltDB run?', [
-            { label: 'Browser', value: 'browser', description: 'local-first with durable browser storage' },
-            { label: 'Node.js', value: 'node', description: 'application server or worker' },
-            { label: 'Self-hosted', value: 'self-hosted', description: 'dedicated FeltDB server' },
-            { label: 'Managed', value: 'managed', description: 'FeltDB-hosted persistence, sync, and workloads' },
-        ], defaults.runtime),
-        framework: await select('Choose an application framework:', [
-            { label: 'React', value: 'react' },
-            { label: 'Vanilla TypeScript', value: 'vanilla' },
-        ], defaults.framework),
-        distributed: await select('Enable distributed operation?', yesNo, defaults.distributed),
-        agents: await select('Include an autonomous agent example?', yesNo, defaults.agents),
-        webllm: await select('Install WebLLM for private natural-language app building?', [
-            { label: 'Yes', value: true, description: 'build FeltDB schemas, capabilities, workflows, and UI locally with AI' },
-            { label: 'No', value: false, description: 'skip the browser model and AI builder' },
-        ], defaults.webllm),
-        capabilities: await select('Choose starter capabilities:', [
+    const runtime = await select('Where does your application\'s data live?', RUNTIME_CHOICES.map(choice => ({ label: choice.label, value: choice.value, description: choice.summary })), defaults.runtime);
+    const framework = await select('Choose an application framework:', [
+        { label: 'React', value: 'react', description: 'a complete starter: sign-up, projects, invitations, activity, assistants' },
+        { label: 'Vanilla TypeScript', value: 'vanilla', description: 'a minimal page over the same database' },
+    ], defaults.framework);
+    // The React starter's assistants are part of its tour and need no model, so
+    // only the vanilla template asks; its capabilities are chosen here too.
+    const agents = framework === 'react' ? true
+        : await select('Include an agent example?', yesNo, defaults.agents);
+    const capabilities = framework === 'react' ? defaults.capabilities
+        : await select('Choose starter capabilities:', [
             { label: 'Search', value: 'search' },
             { label: 'Vector search', value: 'vector' },
             { label: 'Search + vector search', value: 'search,vector' },
-        ], defaults.capabilities),
-    };
+        ], defaults.capabilities);
+    const webllm = await select('Add the private AI app builder (WebLLM)?', [
+        { label: 'No', value: false, description: 'add it later with npm install @feltdb/webllm' },
+        { label: 'Yes', value: true, description: 'builds schemas and UI with a model that runs in your browser: a download of a few hundred MB on first use, and WebGPU' },
+    ], defaults.webllm);
+    // Distribution is a deployment decision, not a first-run one: `--distributed`
+    // records it, and development always runs one local authority.
+    return { runtime, framework, distributed: defaults.distributed, agents, webllm, capabilities };
 }
 async function main() {
     const args = process.argv.slice(2);
@@ -211,9 +216,9 @@ Deployment Target (Explicit):
                           Best for: Client-side apps, offline-first experiences
                           No server required, full offline capability
 
-  --server                Node.js server runtime with server-side FeltDB authority
-                          Best for: Server-side applications, API servers
-                          Requires production FeltDB instance or self-host
+  --server                Data lives in a FeltDB authority the application connects to
+                          Best for: shared state, server-side work, a path to self-hosting
+                          \`feltdb dev\` runs a local authority; deploy to feltdb-server
 
   --self-host             Dedicated FeltDB server with Docker Compose
                           Best for: Staging first, then explicit production promotion
@@ -230,11 +235,15 @@ Options:
   --managed                Explicit: Managed FeltDB service
   --runtime <runtime>      Alternative: Set runtime (browser, node, self-hosted, managed)
   --framework <framework>  Choose framework: react or vanilla (default: react)
-  --no-distributed         Disable distributed operation
-  --no-agents              Exclude agent examples
-  --webllm                 Include the private natural-language FeltDB app builder (default)
-  --no-webllm              Do not install WebLLM or generate the AI builder
-  --capabilities <list>    Choose capabilities: search, vector, or search,vector
+  --distributed            Record that the application will be deployed to several
+                           feltdb-server nodes (development always runs one)
+  --no-distributed         Do not record distributed deployment (default)
+  --no-agents              Exclude the agent example (vanilla template; the React
+                           starter always includes its assistants)
+  --webllm                 Include the private natural-language app builder; downloads
+                           a model into the browser on first use and needs WebGPU
+  --no-webllm              Do not install WebLLM (default)
+  --capabilities <list>    Vanilla template capabilities: search, vector, or search,vector
   --no-install             Skip npm install
   --no-start               Skip automatic feltdb dev startup
   -y, --yes                Use all defaults (non-interactive mode)
@@ -294,13 +303,13 @@ Learn more: https://github.com/rkendel1/feltdb`);
     console.log('\n═══════════════════════════════════════════════');
     console.log('📦 DEPLOYMENT TARGET');
     console.log('═══════════════════════════════════════════════');
-    console.log(`\nRuntime:       ${options.runtime.toUpperCase()}`);
-    console.log(`Description:   ${runtimeDescriptions[options.runtime]}`);
-    console.log(`Framework:     ${options.framework}`);
-    console.log(`Distributed:   ${options.distributed ? 'yes' : 'no'}`);
-    console.log(`Agents:        ${options.agents ? 'yes' : 'no'}`);
-    console.log(`WebLLM:        ${options.webllm ? 'yes — natural-language app builder' : 'no'}`);
-    console.log(`Capabilities:  ${options.capabilities}`);
+    if (options.framework === 'react' && !options.agents) {
+        console.log('\nNote: the React starter always includes its assistants; --no-agents applies to the vanilla template.');
+    }
+    options.agents = agentsIncluded(options);
+    console.log('');
+    for (const line of describeSetup(options))
+        console.log(line);
     console.log('\n═══════════════════════════════════════════════\n');
     const projectDir = path.resolve(process.cwd(), projectName);
     let projectCreated = false;
@@ -362,13 +371,13 @@ Learn more: https://github.com/rkendel1/feltdb`);
             }
         }
         else {
-            console.log('Project is ready. Start the application with:');
+            console.log('Project is ready. Start it with:');
             console.log(`  cd ${projectName}`);
             if (!shouldInstall)
                 console.log('  npm install');
-            console.log('  npm run dev');
-            console.log('Start FeltDB development tooling separately with:');
             console.log('  npm run feltdb:dev');
+            console.log('This starts the application, the development authority, and Studio together.');
+            console.log('Do not also run npm run dev: that second copy is not managed by FeltDB.');
         }
     }
     catch (error) {

package/dist/create/create.js

@@ -196,6 +196,25 @@ ${hasAgents ? `  agent WorkspaceAssistant {
         tsconfig.compilerOptions.types = ['vite/client'];
     }
     fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    // Browsers do not expose VITE_* through process.env, so the database must be handed its
+    // namespace explicitly; otherwise it opens the shared `default` store and `feltdb dev` cannot
+    // recognise the application. A managed (remote) runtime resolves its target from its URL.
+    //
+    // The generated application runs in the browser whatever the deployment target. For a
+    // browser target its state is the browser's own (IndexedDB). For a Node.js or self-hosted
+    // target the state lives in a FeltDB authority, so the browser application connects to it:
+    // the URL the developer configured, else the authority `feltdb dev` started. Opening a
+    // browser store there instead would leave the application writing data Studio and the
+    // authority never see.
+    const namespaceExpression = `import.meta.env.VITE_FELTDB_NAMESPACE || ${JSON.stringify(applicationName)}`;
+    const createDatabaseCall = runtime === 'managed'
+        ? 'createFeltDB()'
+        : runtime === 'browser'
+            ? `createFeltDB({ namespace: ${namespaceExpression} })`
+            : `createFeltDB({
+  namespace: ${namespaceExpression},
+  server: { url: import.meta.env.VITE_FELTDB_URL || import.meta.env.VITE_FELTDB_AUTHORITY_URL || 'http://127.0.0.1:7700' },
+})`;
     // Create main application files
     const feltdbTs = `import { configureDevelopmentRuntimeBridge, createFeltDB } from '@feltdb/core';
 
@@ -209,7 +228,7 @@ configureDevelopmentRuntimeBridge({
   applicationUrl: import.meta.env.VITE_FELTDB_APPLICATION_URL,
 });
 
-export const db = createFeltDB();
+export const db = ${createDatabaseCall};
 
 // Collections
 export const projects = db.collection('Project');
@@ -1193,7 +1212,7 @@ root.render(
             }
             fs.writeFileSync(path.join(projectDir, 'feltdb.flow'), fs.readFileSync(path.join(canonicalTemplate, 'feltdb.flow'), 'utf8').replace('app FeltDBStarter', `app ${appName}`));
             const databasePath = path.join(srcDir, 'feltdb.ts');
-            fs.writeFileSync(databasePath, fs.readFileSync(databasePath, 'utf8').replace(/export const managedRuntime[\s\S]*?\n\} : \{ namespace: import\.meta\.env\.VITE_FELTDB_NAMESPACE \|\| 'feltdb-starter', browser: true \}\);/, `export const managedRuntime = ${runtime === 'managed'};\nexport const db = createFeltDB();`));
+            fs.writeFileSync(databasePath, fs.readFileSync(databasePath, 'utf8').replace(/export const managedRuntime[\s\S]*?\n\} : \{ namespace: import\.meta\.env\.VITE_FELTDB_NAMESPACE \|\| 'feltdb-starter', browser: true \}\);/, `export const managedRuntime = ${runtime === 'managed'};\nexport const db = ${createDatabaseCall};`));
         }
     }
     else {
@@ -1216,6 +1235,8 @@ main().catch(console.error);
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <!-- An inline icon: without one the browser requests /favicon.ico and logs a 404. -->
+  <link rel="icon" href="data:,">
   <title>${applicationName}</title>
 </head>
 <body>
@@ -1558,22 +1579,17 @@ A FeltDB Workspace application demonstrating local-first database capabilities.
 
 ## Quick Start
 
-Start the application:
+Start everything:
 
 \`\`\`bash
 npm install
-npm run dev
-\`\`\`
-
-The application will be available at http://localhost:5173 (or your configured port).
-
-In a second terminal, start FeltDB authority, pairing, and Studio and attach it
-to the application explicitly:
-
-\`\`\`bash
 npm run feltdb:dev
 \`\`\`
 
+\`feltdb dev\` starts the application, the development authority, pairing, and Studio together
+and prints the address of each. Do not also run \`npm run dev\`: that second copy is not
+managed by FeltDB, so Studio cannot see it.
+
 ## FeltDB Workspace Showcase
 
 This application demonstrates core FeltDB capabilities:
@@ -1698,17 +1714,14 @@ Never expose \`FELTDB_MANAGED_CONTROL_API_KEY\` or \`FELTDB_TOKEN\` through a \`
 
 ## Development
 
-### Start Development Server
-\`\`\`bash
-npm run dev
-\`\`\`
-
-### Start FeltDB Development Tooling
-
+### Start the Development Environment
 \`\`\`bash
 npm run feltdb:dev
 \`\`\`
 
+This runs the application (\`npm run dev\` under FeltDB's management), the development authority,
+and Studio. Running \`npm run dev\` yourself starts an unmanaged second copy.
+
 ### Build for Production
 \`\`\`bash
 npm run build

package/dist/create/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.12.1';
+export const FELTDB_PACKAGE_VERSION = '0.13.0';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;

package/dist/create/server-source/Cargo.lock

@@ -494,13 +494,14 @@ checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
 [[package]]
 name = "feltdb"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-stream",
  "async-trait",
  "bincode",
  "criterion",
  "ed25519-dalek",
+ "feltdb",
  "rand 0.8.7",
  "serde",
  "serde_json",
@@ -510,15 +511,29 @@ dependencies = [
  "wasmi",
 ]
 
+[[package]]
+name = "feltdb-client"
+version = "0.2.2"
+dependencies = [
+ "feltdb",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-rustls",
+ "uuid",
+]
+
 [[package]]
 name = "feltdb-server"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "argon2",
  "async-stream",
  "axum",
  "base64",
  "feltdb",
+ "feltdb-client",
  "futures-core",
  "hmac",
  "password-hash",
@@ -537,7 +552,7 @@ dependencies = [
 
 [[package]]
 name = "feltdb-wasm"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "feltdb",
  "getrandom 0.2.17",

package/dist/create/server-source/Cargo.toml

@@ -1,16 +1,18 @@
 [workspace]
-members = ["crates/feltdb", "crates/feltdb-server", "crates/feltdb-wasm"]
+members = ["crates/feltdb", "crates/feltdb-client", "crates/feltdb-server", "crates/feltdb-wasm"]
 # The deterministic contracts' WASM implementations are their own
 # dependency-free workspaces: they are only ever built for
 # wasm32-unknown-unknown, and a second implementation that inherited this
 # workspace's dependencies would stop being an independent one.
 exclude = [
+    "crates/feltdb-public-api-check",
     "crates/feltdb-trigger-contract-wasm",
     "crates/feltdb-state-diff-contract-wasm",
     "crates/feltdb-state-conflict-contract-wasm",
+    "crates/feltdb-agent-transition-contract-wasm",
 ]
 resolver = "2"
 
 [workspace.package]
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"

package/dist/create/server-source/crates/feltdb/Cargo.toml

@@ -2,6 +2,23 @@
 name = "feltdb"
 version.workspace = true
 edition.workspace = true
+# The oldest toolchain CI builds and tests this workspace with (.github/workflows/ci.yml).
+rust-version = "1.96"
+description = "Embedded durable state store: an append-only log with atomic multi-record transactions, version-conditional writes, and idempotent retries"
+license = "MIT"
+repository = "https://github.com/rkendel1/flow_db"
+readme = "README.md"
+keywords = ["database", "embedded", "transactions", "durable", "idempotency"]
+categories = ["database-implementations", "data-structures"]
+# The integration tests and benches read repository files by path (docs, sibling crates) and
+# cannot run from a packaged copy, so they stay in the repository.
+exclude = ["tests/", "benches/", "target/"]
+
+[features]
+default = []
+# Implementation, fault-injection and diagnostic modules. Not part of the supported API: no
+# compatibility promise covers anything this exposes. The workspace's own crates enable it.
+unstable-internals = []
 
 [dependencies]
 serde = { version = "1", features = ["derive"] }
@@ -18,6 +35,9 @@ bincode = "1"
 tokio = { version = "1", features = ["net", "io-util", "rt-multi-thread"] }
 
 [dev-dependencies]
+# The integration tests and benches exercise internals, so they build the crate with them. Packages
+# that want only the supported API depend on `feltdb` without the feature.
+feltdb = { path = ".", features = ["unstable-internals"] }
 criterion = { version = "0.5", features = ["html_reports"] }
 sha2 = "0.10"
 tempfile = "3"

package/dist/create/server-source/crates/feltdb/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FeltDB Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/create/server-source/crates/feltdb/README.md

@@ -0,0 +1,75 @@
+# feltdb
+
+An embedded, durable state store for Rust. Records live in an append-only log on local disk. Several
+records can change in one atomic transaction, a write can be conditional on the version you read, and a
+transaction can carry an identity so that a retry after an uncertain outcome is recognized instead of
+applied twice.
+
+```toml
+[dependencies]
+feltdb = "0.2"
+serde_json = "1"
+```
+
+```rust
+use feltdb::{FeltDb, FlowError};
+use serde_json::json;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let db = FeltDb::open("app.db")?;
+
+    // Create only if absent. A second create is refused in a way you can branch on.
+    db.insert_if_absent("orders:o-1", json!({ "status": "pending" }))?;
+    assert!(matches!(
+        db.insert_if_absent("orders:o-1", json!({})),
+        Err(FlowError::PreconditionFailed(_))
+    ));
+    Ok(())
+}
+```
+
+The crate documentation on docs.rs has a longer, tested example covering atomic transactions and safe
+retries.
+
+## What you can rely on
+
+- Acknowledged writes and committed transaction ids survive closing and reopening the database, and a
+  process kill.
+- An interrupted, unacknowledged append is discarded on open and reported; its retry is treated as a
+  first use.
+- A transaction id names one payload. Reusing an id with a different payload hash fails with
+  `FlowError::TransactionIdPayloadMismatch` and writes nothing.
+
+## What is not promised
+
+- **Power-loss durability is unproven.** A flush hands bytes to the operating system; it does not force
+  them to stable storage. What survives a power cut depends on the filesystem, mount options and the
+  drive. See the repository's
+  [crash durability](https://github.com/rkendel1/flow_db/blob/main/docs/architecture/crash-durability.md)
+  note.
+- **Only the supported API is covered by semver.** While the version is `0.x`, a breaking change to a
+  supported item is a minor-version bump. Everything behind the `unstable-internals` feature (fault
+  injection, diagnostics, implementation modules) carries no promise at all; do not enable it in
+  application code. The supported surface is listed in
+  [the Rust API contract](https://github.com/rkendel1/flow_db/blob/main/docs/reference/feltdb-rust-api.md).
+- Plain `insert`, `update` and `delete` are unconditional: `insert` replaces, `update` of a missing key
+  creates it, `delete` of a missing key succeeds. Use `insert_if_absent` or `compare_and_set_json` when
+  you need a guard.
+
+## Targets
+
+Built and tested on native targets. `wasm32-wasip1` compiles. `wasm32-unknown-unknown` compiles only if
+your crate enables `getrandom`'s `js` feature.
+
+## Binaries
+
+The package also builds `feltdb-authority`, `feltdb-authority-client` and `feltdb_node`, the process
+authority and its client. `cargo install feltdb` installs them. Most applications want only the library.
+
+## Minimum Rust version
+
+1.96, the oldest toolchain the project's CI builds and tests with.
+
+## License
+
+MIT. See [LICENSE](LICENSE).