@serfab/quereus-plugin-sereus 0.8.0

package/dist/plugin.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Quereus plugin entry point for Sereus strand connections (Node).
+ *
+ * Loaded via Quoomb's `.plugin install` or config file, or via `registerPlugin()`.
+ * Parses SqlValue config and delegates to `connectToStrand`.
+ *
+ * Browser/Worker consumers should load `./plugin-browser` instead, which uses
+ * the TCP-free libp2p entry and IndexedDB-backed default storage.
+ */
+import type { Database, SqlValue } from '@quereus/quereus';
+import { parseConfig } from './parse-config.js';
+import type { SereusPluginResult } from './types.js';
+export { parseConfig };
+/**
+ * Default export: Quereus plugin registration function.
+ */
+export default function register(db: Database, config?: Record<string, SqlValue>): Promise<SereusPluginResult>;

package/dist/plugin.js

@@ -0,0 +1,30 @@
+/**
+ * Quereus plugin entry point for Sereus strand connections (Node).
+ *
+ * Loaded via Quoomb's `.plugin install` or config file, or via `registerPlugin()`.
+ * Parses SqlValue config and delegates to `connectToStrand`.
+ *
+ * Browser/Worker consumers should load `./plugin-browser` instead, which uses
+ * the TCP-free libp2p entry and IndexedDB-backed default storage.
+ */
+import { connectToStrand } from './connect.js';
+import { parseConfig } from './parse-config.js';
+export { parseConfig };
+/**
+ * Default export: Quereus plugin registration function.
+ */
+export default async function register(db, config = {}) {
+    const options = parseConfig(config);
+    // `storage_path` is a Node-only loader convenience: a `Record<string, SqlValue>`
+    // cannot carry an `IRawStorage`, so the path is resolved to a concrete
+    // `FileRawStorage` here (not in the platform-agnostic `parseConfig`). The
+    // dynamic import keeps `@optimystic/db-p2p-storage-fs` (and its `node:fs`
+    // dependency) out of the browser/RN module graph.
+    const storagePath = config.storage_path;
+    if (typeof storagePath === 'string' && storagePath) {
+        const { FileRawStorage } = await import('@optimystic/db-p2p-storage-fs');
+        options.storage = new FileRawStorage(storagePath);
+    }
+    return connectToStrand(db, options);
+}
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EAAE,WAAW,EAAE,CAAC;AAEvB;;GAEG;AACH,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,QAAQ,CACrC,EAAY,EACZ,SAAmC,EAAE;IAErC,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;IAEpC,iFAAiF;IACjF,uEAAuE;IACvE,0EAA0E;IAC1E,0EAA0E;IAC1E,kDAAkD;IAClD,MAAM,WAAW,GAAG,MAAM,CAAC,YAAY,CAAC;IACxC,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,EAAE,CAAC;QACpD,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,+BAA+B,CAAC,CAAC;QACzE,OAAO,CAAC,OAAO,GAAG,IAAI,cAAc,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED,OAAO,eAAe,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;AACrC,CAAC"}

package/dist/strand-schema.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Embedded strand membership/RBAC schema for cross-platform compatibility.
+ *
+ * This is the authoritative runtime copy of the `Strand` membership schema. It
+ * is duplicated from `schemas/strand.qsql` so that React Native and other
+ * filesystem-less environments get the schema without a runtime file read —
+ * the same pattern `CONTROL_SCHEMA` (cadre-core) uses for the control schema.
+ *
+ * `STRAND_SCHEMA` holds only the *body* (the inner table declarations). The
+ * shared composition (`composeStrand`) wraps it in
+ * `declare schema Strand { ... } apply schema Strand;`, mirroring how the sApp
+ * schema is wrapped in `declare schema App { ... }`.
+ *
+ * Drift discipline: the table declarations here MUST stay byte-equivalent to the
+ * body of `schemas/strand.qsql` (the on-disk canonical copy). Any edit here must
+ * be mirrored there and vice versa — the same invariant the planned
+ * `control-schema-drift-guard` enforces for the control schema.
+ *
+ * Crypto idiom (matches `schemas/control.qsql` and the sApp RBAC fixture
+ * `packages/integration-tests/fixtures/simple-sapp.qsql`): every signed write
+ * proves itself with `verify(digest(<concatenated payload>, 'sha256', 'utf8'),
+ * <signature>, <pubkey>, 'ed25519')`. Member keys are ed25519, so the explicit
+ * curve arg is REQUIRED (verify() otherwise defaults to secp256k1).
+ *
+ * Population note: this ticket applies the schema and makes its constraints
+ * active — it does NOT write membership rows at runtime. Inserting the `Header`,
+ * the founding `Authority`/`Member`, and the invite/peer flows is owned by
+ * `strand-membership-lifecycle-population`.
+ */
+export declare const STRAND_SCHEMA = "    table Header (\n        Id text,    -- UUID of this network - generated at inception - immutable\n\n        -- Types: 'o' = Open, 'c' = Closed\n        -- Any peers can join an open network, but only members can join a closed network\n        -- Open can still control writes in the app, but only Closed prevents reads\n        Type text check (Type in ('o', 'c')),\n\n        -- The app that this strand faciliates - public key from author to prevent tampering\n        sAppId text,\n\n        -- The version of the sApp that this strand faciliates\n        sAppVersion text,\n\n        -- The schema of the sApp that this strand faciliates\n        sAppSchema text,\n\n        -- The author's signature on the schema to guarantee authorship\n        sAppSignature text,\n\n        -- The engine (rules logic system) that is assumed to manage this strand\n        Engine text,\n\n        -- The version of the engine that is assumed to manage this strand\n        EngineVersion text,\n\n        primary key (/* empty - singleton */),\n        constraint InsertOnly check on update, delete (false),  -- One-time insert only for now - TODO: revisit for versioning\n    );\n\n    -- An invitation to join a strand as a member\n    table Invite (\n        Key text primary key,\n        Expiration datetime null,\n        -- TODO: ability to deactivate?\n        constraint InsertOnly check on update, delete (false),\n        constraint OnlyClosed check (\n            exists (select 1 from Header H where H.Type = 'c')\n        ),\n        constraint InviteValid check on insert (\n            -- Can only be inserted by an authority,\n            exists (select 1 from Authority A\n                where A.MemberKey = context.AuthorityKey\n                    and verify(digest(new.Key || '|' || coalesce(new.Expiration, ''), 'sha256', 'utf8'), context.AuthoritySignature, A.MemberKey, 'ed25519')\n            )\n                -- and must also prove invite private key held by issuing authority\n                and verify(digest(new.Key || '|' || coalesce(new.Expiration, ''), 'sha256', 'utf8'), context.InviteSignature, new.Key, 'ed25519')\n        )\n    ) with context (AuthorityKey text null, AuthoritySignature text null, InviteSignature text null);\n\n    -- Invite [InviteKey] has been used to add [MemberKey] as a member\n    table ConsumedInvite (\n        InviteKey text primary key,\n        MemberKey text,\n        constraint InsertOnly check on update, delete (false),\n        constraint InviteExists check (exists (select 1 from Invite I where I.Key = new.InviteKey)),\n        constraint MemberExists check (exists (select 1 from Member M where M.Key = new.MemberKey)),\n        constraint ValidUsage check on insert (\n            exists (select 1 from Invite I where I.Key = new.InviteKey and verify(digest(new.InviteKey || '|' || new.MemberKey, 'sha256', 'utf8'), context.InviteSignature, new.InviteKey, 'ed25519'))\n        ),\n        constraint MemberValid check (exists (select 1 from Member M where M.Key = new.MemberKey))\n    ) with context (InviteSignature text null);\n\n    -- A party in the closed strand network\n    table Member (\n        Key text primary key,\n        constraint NoUpdate check on update (false),\n        constraint OnlyClosed check (\n            exists (select 1 from Header H where H.Type = 'c')\n        ),\n        constraint Authorized check on insert (\n            -- There are no other records - first member needs no authorization\n            (select count(1) from Member) <= 1\n\n                -- or added directly by authority\n                or exists (\n                    select 1 from Authority A\n                        where A.MemberKey = context.AuthorityKey\n                            and verify(digest(new.Key, 'sha256', 'utf8'), context.AuthoritySignature, A.MemberKey, 'ed25519')\n                )\n\n                -- or added by invite\n                or exists (\n                    select 1 from ConsumedInvite CI where CI.MemberKey = new.Key\n                )\n        ),\n        -- TODO: handle member revocation constraint\n    ) with context (AuthorityKey text null, AuthoritySignature text null);\n\n    -- A member-associated peer (node)\n    table MemberPeer (\n        MemberKey text,\n        PeerId text,\n        primary key (MemberKey, PeerId),\n        constraint MemberExists check (exists (select 1 from Member M where M.Key = new.MemberKey)),\n        constraint Authorized check (\n            verify(\n                digest(coalesce(new.MemberKey, old.MemberKey) || '|' || coalesce(new.PeerId, old.PeerId), 'sha256', 'utf8'),\n                context.Signature,\n                coalesce(new.MemberKey, old.MemberKey),\n                'ed25519'\n            )\n        ),\n    ) with context (Signature text null);\n\n    -- An authority is a member that can issue invites, authorize members, and rotate authorities\n    table Authority (\n        MemberKey text primary key,\n        constraint OnlyClosed check (\n            exists (select 1 from Header H where H.Type = 'c')\n        ),\n        constraint Authorized check (\n            -- There are no existing records - first authority needs no authorization\n            (select count(1) from Authority) <= 1\n\n                -- or authorized by this former authority\n                or (\n                    old.MemberKey is not null\n                        and old.MemberKey = context.AuthorityKey\n                        and verify(digest(old.MemberKey, 'sha256', 'utf8'), context.Signature, old.MemberKey, 'ed25519')\n                )\n\n                -- or authorized by another existing authority\n                or exists (\n                    select 1 from Authority A\n                        where A.MemberKey = context.AuthorityKey\n                            and verify(digest(coalesce(new.MemberKey, old.MemberKey), 'sha256', 'utf8'), context.Signature, A.MemberKey, 'ed25519')\n                )\n        )\n    ) with context (AuthorityKey text null, Signature text null);\n";

package/dist/strand-schema.js

@@ -0,0 +1,161 @@
+/**
+ * Embedded strand membership/RBAC schema for cross-platform compatibility.
+ *
+ * This is the authoritative runtime copy of the `Strand` membership schema. It
+ * is duplicated from `schemas/strand.qsql` so that React Native and other
+ * filesystem-less environments get the schema without a runtime file read —
+ * the same pattern `CONTROL_SCHEMA` (cadre-core) uses for the control schema.
+ *
+ * `STRAND_SCHEMA` holds only the *body* (the inner table declarations). The
+ * shared composition (`composeStrand`) wraps it in
+ * `declare schema Strand { ... } apply schema Strand;`, mirroring how the sApp
+ * schema is wrapped in `declare schema App { ... }`.
+ *
+ * Drift discipline: the table declarations here MUST stay byte-equivalent to the
+ * body of `schemas/strand.qsql` (the on-disk canonical copy). Any edit here must
+ * be mirrored there and vice versa — the same invariant the planned
+ * `control-schema-drift-guard` enforces for the control schema.
+ *
+ * Crypto idiom (matches `schemas/control.qsql` and the sApp RBAC fixture
+ * `packages/integration-tests/fixtures/simple-sapp.qsql`): every signed write
+ * proves itself with `verify(digest(<concatenated payload>, 'sha256', 'utf8'),
+ * <signature>, <pubkey>, 'ed25519')`. Member keys are ed25519, so the explicit
+ * curve arg is REQUIRED (verify() otherwise defaults to secp256k1).
+ *
+ * Population note: this ticket applies the schema and makes its constraints
+ * active — it does NOT write membership rows at runtime. Inserting the `Header`,
+ * the founding `Authority`/`Member`, and the invite/peer flows is owned by
+ * `strand-membership-lifecycle-population`.
+ */
+export const STRAND_SCHEMA = `    table Header (
+        Id text,    -- UUID of this network - generated at inception - immutable
+
+        -- Types: 'o' = Open, 'c' = Closed
+        -- Any peers can join an open network, but only members can join a closed network
+        -- Open can still control writes in the app, but only Closed prevents reads
+        Type text check (Type in ('o', 'c')),
+
+        -- The app that this strand faciliates - public key from author to prevent tampering
+        sAppId text,
+
+        -- The version of the sApp that this strand faciliates
+        sAppVersion text,
+
+        -- The schema of the sApp that this strand faciliates
+        sAppSchema text,
+
+        -- The author's signature on the schema to guarantee authorship
+        sAppSignature text,
+
+        -- The engine (rules logic system) that is assumed to manage this strand
+        Engine text,
+
+        -- The version of the engine that is assumed to manage this strand
+        EngineVersion text,
+
+        primary key (/* empty - singleton */),
+        constraint InsertOnly check on update, delete (false),  -- One-time insert only for now - TODO: revisit for versioning
+    );
+
+    -- An invitation to join a strand as a member
+    table Invite (
+        Key text primary key,
+        Expiration datetime null,
+        -- TODO: ability to deactivate?
+        constraint InsertOnly check on update, delete (false),
+        constraint OnlyClosed check (
+            exists (select 1 from Header H where H.Type = 'c')
+        ),
+        constraint InviteValid check on insert (
+            -- Can only be inserted by an authority,
+            exists (select 1 from Authority A
+                where A.MemberKey = context.AuthorityKey
+                    and verify(digest(new.Key || '|' || coalesce(new.Expiration, ''), 'sha256', 'utf8'), context.AuthoritySignature, A.MemberKey, 'ed25519')
+            )
+                -- and must also prove invite private key held by issuing authority
+                and verify(digest(new.Key || '|' || coalesce(new.Expiration, ''), 'sha256', 'utf8'), context.InviteSignature, new.Key, 'ed25519')
+        )
+    ) with context (AuthorityKey text null, AuthoritySignature text null, InviteSignature text null);
+
+    -- Invite [InviteKey] has been used to add [MemberKey] as a member
+    table ConsumedInvite (
+        InviteKey text primary key,
+        MemberKey text,
+        constraint InsertOnly check on update, delete (false),
+        constraint InviteExists check (exists (select 1 from Invite I where I.Key = new.InviteKey)),
+        constraint MemberExists check (exists (select 1 from Member M where M.Key = new.MemberKey)),
+        constraint ValidUsage check on insert (
+            exists (select 1 from Invite I where I.Key = new.InviteKey and verify(digest(new.InviteKey || '|' || new.MemberKey, 'sha256', 'utf8'), context.InviteSignature, new.InviteKey, 'ed25519'))
+        ),
+        constraint MemberValid check (exists (select 1 from Member M where M.Key = new.MemberKey))
+    ) with context (InviteSignature text null);
+
+    -- A party in the closed strand network
+    table Member (
+        Key text primary key,
+        constraint NoUpdate check on update (false),
+        constraint OnlyClosed check (
+            exists (select 1 from Header H where H.Type = 'c')
+        ),
+        constraint Authorized check on insert (
+            -- There are no other records - first member needs no authorization
+            (select count(1) from Member) <= 1
+
+                -- or added directly by authority
+                or exists (
+                    select 1 from Authority A
+                        where A.MemberKey = context.AuthorityKey
+                            and verify(digest(new.Key, 'sha256', 'utf8'), context.AuthoritySignature, A.MemberKey, 'ed25519')
+                )
+
+                -- or added by invite
+                or exists (
+                    select 1 from ConsumedInvite CI where CI.MemberKey = new.Key
+                )
+        ),
+        -- TODO: handle member revocation constraint
+    ) with context (AuthorityKey text null, AuthoritySignature text null);
+
+    -- A member-associated peer (node)
+    table MemberPeer (
+        MemberKey text,
+        PeerId text,
+        primary key (MemberKey, PeerId),
+        constraint MemberExists check (exists (select 1 from Member M where M.Key = new.MemberKey)),
+        constraint Authorized check (
+            verify(
+                digest(coalesce(new.MemberKey, old.MemberKey) || '|' || coalesce(new.PeerId, old.PeerId), 'sha256', 'utf8'),
+                context.Signature,
+                coalesce(new.MemberKey, old.MemberKey),
+                'ed25519'
+            )
+        ),
+    ) with context (Signature text null);
+
+    -- An authority is a member that can issue invites, authorize members, and rotate authorities
+    table Authority (
+        MemberKey text primary key,
+        constraint OnlyClosed check (
+            exists (select 1 from Header H where H.Type = 'c')
+        ),
+        constraint Authorized check (
+            -- There are no existing records - first authority needs no authorization
+            (select count(1) from Authority) <= 1
+
+                -- or authorized by this former authority
+                or (
+                    old.MemberKey is not null
+                        and old.MemberKey = context.AuthorityKey
+                        and verify(digest(old.MemberKey, 'sha256', 'utf8'), context.Signature, old.MemberKey, 'ed25519')
+                )
+
+                -- or authorized by another existing authority
+                or exists (
+                    select 1 from Authority A
+                        where A.MemberKey = context.AuthorityKey
+                            and verify(digest(coalesce(new.MemberKey, old.MemberKey), 'sha256', 'utf8'), context.Signature, A.MemberKey, 'ed25519')
+                )
+        )
+    ) with context (AuthorityKey text null, Signature text null);
+`;
+//# sourceMappingURL=strand-schema.js.map

package/dist/strand-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strand-schema.js","sourceRoot":"","sources":["../src/strand-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkI5B,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+import type { Libp2p } from '@libp2p/interface';
+import type { IRepo } from '@optimystic/db-core';
+import type { IRawStorage } from '@optimystic/db-p2p';
+export interface StrandConnectionOptions {
+    /** UUID of the strand to connect to */
+    strandId: string;
+    /** Bootstrap multiaddrs for peer discovery */
+    bootstrapNodes?: string[];
+    /** sApp schema DDL to apply (optional - omit if schema already exists on strand) */
+    schema?: string;
+    /** sApp author public key */
+    sAppId?: string;
+    /** sApp version */
+    sAppVersion?: string;
+    /** libp2p listening port (default: 0 = random) */
+    port?: number;
+    /** Enable optimystic caching (default: true) */
+    enableCache?: boolean;
+    /** FRET profile (default: 'edge') */
+    fretProfile?: 'edge' | 'core';
+    /** Inject an existing libp2p node instead of creating one */
+    libp2pNode?: Libp2p;
+    /** Required when libp2pNode is provided */
+    coordinatedRepo?: IRepo;
+    /**
+     * Lifecycle mode. `'networked'` (default) uses the network transactor and
+     * is appropriate for multi-peer participation. `'bootstrap'` switches to a
+     * local transactor so a solo node can apply schema and accept DML with no
+     * peer round trips; pair it with a persistent `storage` to survive restart.
+     */
+    mode?: 'bootstrap' | 'networked';
+    /**
+     * Persistent raw storage. When provided:
+     *  - it is passed to `createLibp2pNode` as `storage` so the libp2p data path uses it,
+     *  - in `bootstrap` mode it is also handed to the optimystic plugin as
+     *    `rawStorageFactory: () => storage` so the local transactor persists DML
+     *    on the same instance (avoids cache divergence between the two consumers).
+     *
+     * The plugin treats `storage` as borrowed — it is NOT closed on `shutdown()`.
+     */
+    storage?: IRawStorage;
+    /** @internal Override transactor type. Used by unit tests with `'test'`. When set, takes precedence only if `mode` is not specified. */
+    transactor?: string;
+}
+export interface SereusPluginResult {
+    vtables: [];
+    functions: [];
+    collations: [];
+    /**
+     * Catalog-hydration counts from the warm-restart hydrate that runs before
+     * `apply schema App;`. On a cold start (empty storage) both are 0; on a warm
+     * restart they report the persisted tables/indexes the catalog was primed
+     * with — so a test can assert hydration actually ran. `undefined` only if
+     * composition threw before hydrate.
+     */
+    hydrated?: {
+        tables: number;
+        indexes: number;
+    };
+    /** Shuts down the libp2p node and collection factory. Call when done. */
+    shutdown: () => Promise<void>;
+}
+/**
+ * Extended Libp2p node type with coordinatedRepo attached by createLibp2pNode.
+ * @internal
+ */
+export interface Libp2pNodeWithRepo extends Libp2p {
+    coordinatedRepo: IRepo;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "@serfab/quereus-plugin-sereus",
+  "version": "0.8.0",
+  "type": "module",
+  "description": "Quereus plugin that connects to a Sereus strand for SQL access",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "browser": "./dist/plugin-browser.js",
+      "import": "./dist/plugin.js"
+    },
+    "./plugin-browser": {
+      "types": "./dist/plugin-browser.d.ts",
+      "import": "./dist/plugin-browser.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gotchoices/sereus.git",
+    "directory": "packages/quereus-plugin-sereus"
+  },
+  "author": "Got Choices Foundation",
+  "license": "MIT",
+  "keywords": [
+    "quereus-plugin",
+    "quereus",
+    "sereus",
+    "strand",
+    "distributed",
+    "database",
+    "sql",
+    "p2p"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsc -p tsconfig.build.json && node scripts/build-browser.mjs",
+    "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
+    "test": "vitest run",
+    "test:e2e": "vitest run --project e2e",
+    "dev:test": "vitest"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/node": "^25.0.10",
+    "@vitest/coverage-v8": "^4.0.17",
+    "acorn": "^8.12.0",
+    "esbuild": "^0.27.2",
+    "fake-indexeddb": "^6.2.4",
+    "jsdom": "^25.0.1",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "dependencies": {
+    "@libp2p/circuit-relay-v2": "^4.1.3",
+    "@libp2p/interface": "^3.1.0",
+    "@libp2p/websockets": "^10.1.3",
+    "@optimystic/db-core": "^0.13.5",
+    "@optimystic/db-p2p": "^0.13.5",
+    "@optimystic/db-p2p-storage-fs": "^0.13.5",
+    "@optimystic/db-p2p-storage-web": "^0.13.5",
+    "@optimystic/quereus-plugin-crypto": "^0.13.5",
+    "@optimystic/quereus-plugin-optimystic": "^0.13.5",
+    "@quereus/quereus": "^3.2.1",
+    "debug": "^4.4.3"
+  },
+  "quereus": {
+    "provides": {
+      "vtables": [
+        "optimystic"
+      ],
+      "functions": [
+        "StampId",
+        "digest",
+        "sign",
+        "verify",
+        "randomBytes"
+      ]
+    },
+    "settings": [
+      {
+        "key": "strand_id",
+        "type": "string"
+      },
+      {
+        "key": "bootstrap_nodes",
+        "type": "string",
+        "default": ""
+      },
+      {
+        "key": "schema",
+        "type": "string"
+      },
+      {
+        "key": "sapp_id",
+        "type": "string",
+        "default": "unknown"
+      },
+      {
+        "key": "sapp_version",
+        "type": "string",
+        "default": "1.0.0"
+      },
+      {
+        "key": "port",
+        "type": "number",
+        "default": 0
+      },
+      {
+        "key": "enable_cache",
+        "type": "boolean",
+        "default": true
+      },
+      {
+        "key": "fret_profile",
+        "type": "string",
+        "default": "edge"
+      },
+      {
+        "key": "mode",
+        "type": "string"
+      },
+      {
+        "key": "transactor",
+        "type": "string"
+      },
+      {
+        "key": "storage_path",
+        "type": "string"
+      }
+    ]
+  }
+}