kibi-cli 2.32.0 → 2.35.1

package/dist/public/operations/specs/mutation-schemas.d.ts

@@ -211,12 +211,24 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                 };
                 readonly kind: {
                     readonly type: "string";
-                    readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt"];
-                    readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic and smt must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved.";
+                    readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt", "rule", "state_machine", "regex", "source"];
+                    readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic, smt, rule, state_machine and regex must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved. source reads the contract's source itself: the run may leave {version, kind: source, test_id, source} or nothing, and Kibi stores its own read as the certificate.";
+                };
+                readonly source: {
+                    readonly description: "source: the project source a source proof reads. A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                    readonly type: "object";
+                    readonly required: readonly ["reader"];
+                    readonly properties: {
+                        readonly reader: {
+                            readonly type: "string";
+                            readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                        };
+                    };
+                    readonly additionalProperties: true;
                 };
                 readonly domain_source: {
                     readonly type: "object";
-                    readonly description: "exhaustive and typecheck: the symbol that defines the finite domain. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.";
+                    readonly description: "exhaustive and typecheck: the symbol that defines the finite domain (typecheck: also the type whose fields a required_fields fact names). state_machine: the transition table or next-state function. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.";
                     readonly required: readonly ["symbol_id"];
                     readonly properties: {
                         readonly symbol_id: {
@@ -245,7 +257,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                 };
                 readonly proves: {
                     readonly type: "array";
-                    readonly description: "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt); a claim with no such derivation is only attested and never counts as proved.";
+                    readonly description: "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt, a rule, predicate or set fact for rule and state_machine, a string fact for regex); a claim with no such derivation is only attested and never counts as proved.";
                     readonly minItems: 1;
                     readonly items: {
                         readonly type: "string";
@@ -255,9 +267,45 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                 };
                 readonly value_source: {
                     readonly type: "array";
-                    readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base.";
+                    readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
                     readonly minItems: 1;
                     readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly symbol_id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly export: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly source: {
+                                readonly type: "object";
+                                readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                readonly required: readonly ["reader"];
+                                readonly properties: {
+                                    readonly reader: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                    };
+                                };
+                                readonly additionalProperties: true;
+                            };
+                            readonly measure: {
+                                readonly type: "string";
+                                readonly enum: readonly ["value", "count"];
+                                readonly description: "value (default for an export): the export is a number. count (the only measure of a source): the number of members of a list, set, map or object export, or of a source.";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly predicate_source: {
+                    readonly type: "object";
+                    readonly description: "rule: the code function behind each predicate a claim's rule, predicate or set fact names, keyed by predicate name. Each export takes the predicate's arguments in order and returns a boolean; Kibi calls it on every combination of its argument domains.";
+                    readonly minProperties: 1;
+                    readonly additionalProperties: {
                         readonly type: "object";
                         readonly required: readonly ["symbol_id"];
                         readonly properties: {
@@ -268,11 +316,93 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                             readonly export: {
                                 readonly type: "string";
                                 readonly minLength: 1;
+                                readonly description: "The exported function's name in the symbol's source file. Without it Kibi reads the export named by the symbol's title.";
+                            };
+                            readonly harness_for: {
+                                readonly type: "array";
+                                readonly minItems: 1;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly description: "The predicate is a test harness that decides the predicate by driving these code symbols (for example by calling the handler with each role). The symbols must be covered_by the test; a claim the harness proves is bound with scope harness.";
                             };
                         };
                         readonly additionalProperties: false;
                     };
                 };
+                readonly domains: {
+                    readonly type: "object";
+                    readonly description: "rule: the finite domain of each argument type, keyed by type name (an array, Set, Map or object export, or a Python list, set, dict or Enum), or {source} for the members Kibi reads from a project source (every route, every table, every environment variable). state_machine with a next-state function: the `state` and `event` domains it is called on.";
+                    readonly minProperties: 1;
+                    readonly additionalProperties: {
+                        readonly anyOf: readonly [{
+                            readonly type: "object";
+                            readonly required: readonly ["symbol_id"];
+                            readonly properties: {
+                                readonly symbol_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly export: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "object";
+                            readonly required: readonly ["source"];
+                            readonly properties: {
+                                readonly source: {
+                                    readonly type: "object";
+                                    readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                    readonly required: readonly ["reader"];
+                                    readonly properties: {
+                                        readonly reader: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                        };
+                                    };
+                                    readonly additionalProperties: true;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        }];
+                    };
+                };
+                readonly initial_source: {
+                    readonly description: "state_machine: the export holding the initial state (or states), needed for initial_states and reachable_states facts.";
+                    readonly type: "object";
+                    readonly required: readonly ["symbol_id"];
+                    readonly properties: {
+                        readonly symbol_id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly export: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+                readonly pattern_source: {
+                    readonly description: "regex: the export holding the code's pattern (a RegExp, or a Python re.Pattern) or string constant that a string fact is about.";
+                    readonly type: "object";
+                    readonly required: readonly ["symbol_id"];
+                    readonly properties: {
+                        readonly symbol_id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly export: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
                 readonly constraint_source: {
                     readonly type: "object";
                     readonly description: "arithmetic and smt: the typed numeric property_value facts the certificate's assumptions come from. Kibi checks the assumptions (or the query's assertions) are exactly these facts' constraints, so the proof is about the knowledge base, not numbers the test chose.";
@@ -524,7 +654,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                     };
                     readonly kind: {
                         readonly type: "string";
-                        readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt"];
+                        readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt", "rule", "state_machine", "regex", "source"];
                     };
                     readonly evidence_level: {
                         readonly type: "string";
@@ -566,7 +696,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                                 };
                                 readonly scope: {
                                     readonly type: "string";
-                                    readonly enum: readonly ["code", "intent"];
+                                    readonly enum: readonly ["code", "source", "harness", "intent"];
                                 };
                                 readonly obligation: {
                                     readonly type: "object";
@@ -621,13 +751,13 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
         };
         readonly operator: {
             readonly type: "string";
-            readonly enum: readonly ["eq", "neq", "lt", "lte", "gt", "gte"];
-            readonly description: "Optional comparison operator for property_value facts. Example: 'eq'.";
+            readonly enum: readonly ["eq", "neq", "lt", "lte", "gt", "gte", "matches", "includes", "subset_of", "excludes"];
+            readonly description: "Optional comparison operator for property_value facts. Example: 'eq'. 'matches' (string facts only): value_string is a JavaScript regular expression (u flag) every value must match as a whole. Set facts only: 'includes' means every member of value_set has the property and other members may have it too; 'subset_of' means every member that has the property is in value_set ('every env var the server reads is one of ...'); 'excludes' means no member of value_set has it ('never imports md5'); 'eq' on a set means exactly those members.";
         };
         readonly value_type: {
             readonly type: "string";
             readonly enum: readonly ["string", "int", "number", "bool", "set"];
-            readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, value_bool, or value_set (set: an exact list of allowed values, operator eq or neq); do not use generic value.";
+            readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, value_bool, or value_set (set: a list of members, with operator eq, includes, subset_of or excludes); do not use generic value.";
         };
         readonly value_string: {
             readonly type: "string";

package/dist/public/operations/specs/mutation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,gFASf,CAAC;AAWX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwY3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}
+{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,gFASf,CAAC;AAWX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmZ3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}

package/dist/public/operations/specs/mutation-schemas.js

@@ -205,13 +205,24 @@ export const ENTITY_PROPERTIES_SCHEMA = {
         },
         operator: {
             type: "string",
-            enum: ["eq", "neq", "lt", "lte", "gt", "gte"],
-            description: "Optional comparison operator for property_value facts. Example: 'eq'.",
+            enum: [
+                "eq",
+                "neq",
+                "lt",
+                "lte",
+                "gt",
+                "gte",
+                "matches",
+                "includes",
+                "subset_of",
+                "excludes",
+            ],
+            description: "Optional comparison operator for property_value facts. Example: 'eq'. 'matches' (string facts only): value_string is a JavaScript regular expression (u flag) every value must match as a whole. Set facts only: 'includes' means every member of value_set has the property and other members may have it too; 'subset_of' means every member that has the property is in value_set ('every env var the server reads is one of ...'); 'excludes' means no member of value_set has it ('never imports md5'); 'eq' on a set means exactly those members.",
         },
         value_type: {
             type: "string",
             enum: ["string", "int", "number", "bool", "set"],
-            description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, value_bool, or value_set (set: an exact list of allowed values, operator eq or neq); do not use generic value.",
+            description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, value_bool, or value_set (set: a list of members, with operator eq, includes, subset_of or excludes); do not use generic value.",
         },
         value_string: {
             type: "string",

package/dist/public/operations/specs/upsert.d.ts

@@ -228,12 +228,24 @@ export declare const upsertSpec: {
                             };
                             readonly kind: {
                                 readonly type: "string";
-                                readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt"];
-                                readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic and smt must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved.";
+                                readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt", "rule", "state_machine", "regex", "source"];
+                                readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic, smt, rule, state_machine and regex must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved. source reads the contract's source itself: the run may leave {version, kind: source, test_id, source} or nothing, and Kibi stores its own read as the certificate.";
+                            };
+                            readonly source: {
+                                readonly description: "source: the project source a source proof reads. A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                readonly type: "object";
+                                readonly required: readonly ["reader"];
+                                readonly properties: {
+                                    readonly reader: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                    };
+                                };
+                                readonly additionalProperties: true;
                             };
                             readonly domain_source: {
                                 readonly type: "object";
-                                readonly description: "exhaustive and typecheck: the symbol that defines the finite domain. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.";
+                                readonly description: "exhaustive and typecheck: the symbol that defines the finite domain (typecheck: also the type whose fields a required_fields fact names). state_machine: the transition table or next-state function. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.";
                                 readonly required: readonly ["symbol_id"];
                                 readonly properties: {
                                     readonly symbol_id: {
@@ -262,7 +274,7 @@ export declare const upsertSpec: {
                             };
                             readonly proves: {
                                 readonly type: "array";
-                                readonly description: "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt); a claim with no such derivation is only attested and never counts as proved.";
+                                readonly description: "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt, a rule, predicate or set fact for rule and state_machine, a string fact for regex); a claim with no such derivation is only attested and never counts as proved.";
                                 readonly minItems: 1;
                                 readonly items: {
                                     readonly type: "string";
@@ -272,9 +284,45 @@ export declare const upsertSpec: {
                             };
                             readonly value_source: {
                                 readonly type: "array";
-                                readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base.";
+                                readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
                                 readonly minItems: 1;
                                 readonly items: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly symbol_id: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly export: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly source: {
+                                            readonly type: "object";
+                                            readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                            readonly required: readonly ["reader"];
+                                            readonly properties: {
+                                                readonly reader: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                                };
+                                            };
+                                            readonly additionalProperties: true;
+                                        };
+                                        readonly measure: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["value", "count"];
+                                            readonly description: "value (default for an export): the export is a number. count (the only measure of a source): the number of members of a list, set, map or object export, or of a source.";
+                                        };
+                                    };
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                            readonly predicate_source: {
+                                readonly type: "object";
+                                readonly description: "rule: the code function behind each predicate a claim's rule, predicate or set fact names, keyed by predicate name. Each export takes the predicate's arguments in order and returns a boolean; Kibi calls it on every combination of its argument domains.";
+                                readonly minProperties: 1;
+                                readonly additionalProperties: {
                                     readonly type: "object";
                                     readonly required: readonly ["symbol_id"];
                                     readonly properties: {
@@ -285,11 +333,93 @@ export declare const upsertSpec: {
                                         readonly export: {
                                             readonly type: "string";
                                             readonly minLength: 1;
+                                            readonly description: "The exported function's name in the symbol's source file. Without it Kibi reads the export named by the symbol's title.";
+                                        };
+                                        readonly harness_for: {
+                                            readonly type: "array";
+                                            readonly minItems: 1;
+                                            readonly items: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly description: "The predicate is a test harness that decides the predicate by driving these code symbols (for example by calling the handler with each role). The symbols must be covered_by the test; a claim the harness proves is bound with scope harness.";
                                         };
                                     };
                                     readonly additionalProperties: false;
                                 };
                             };
+                            readonly domains: {
+                                readonly type: "object";
+                                readonly description: "rule: the finite domain of each argument type, keyed by type name (an array, Set, Map or object export, or a Python list, set, dict or Enum), or {source} for the members Kibi reads from a project source (every route, every table, every environment variable). state_machine with a next-state function: the `state` and `event` domains it is called on.";
+                                readonly minProperties: 1;
+                                readonly additionalProperties: {
+                                    readonly anyOf: readonly [{
+                                        readonly type: "object";
+                                        readonly required: readonly ["symbol_id"];
+                                        readonly properties: {
+                                            readonly symbol_id: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly export: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    }, {
+                                        readonly type: "object";
+                                        readonly required: readonly ["source"];
+                                        readonly properties: {
+                                            readonly source: {
+                                                readonly type: "object";
+                                                readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                                readonly required: readonly ["reader"];
+                                                readonly properties: {
+                                                    readonly reader: {
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                                    };
+                                                };
+                                                readonly additionalProperties: true;
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    }];
+                                };
+                            };
+                            readonly initial_source: {
+                                readonly description: "state_machine: the export holding the initial state (or states), needed for initial_states and reachable_states facts.";
+                                readonly type: "object";
+                                readonly required: readonly ["symbol_id"];
+                                readonly properties: {
+                                    readonly symbol_id: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly export: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                            readonly pattern_source: {
+                                readonly description: "regex: the export holding the code's pattern (a RegExp, or a Python re.Pattern) or string constant that a string fact is about.";
+                                readonly type: "object";
+                                readonly required: readonly ["symbol_id"];
+                                readonly properties: {
+                                    readonly symbol_id: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly export: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
                             readonly constraint_source: {
                                 readonly type: "object";
                                 readonly description: "arithmetic and smt: the typed numeric property_value facts the certificate's assumptions come from. Kibi checks the assumptions (or the query's assertions) are exactly these facts' constraints, so the proof is about the knowledge base, not numbers the test chose.";
@@ -541,7 +671,7 @@ export declare const upsertSpec: {
                                 };
                                 readonly kind: {
                                     readonly type: "string";
-                                    readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt"];
+                                    readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt", "rule", "state_machine", "regex", "source"];
                                 };
                                 readonly evidence_level: {
                                     readonly type: "string";
@@ -583,7 +713,7 @@ export declare const upsertSpec: {
                                             };
                                             readonly scope: {
                                                 readonly type: "string";
-                                                readonly enum: readonly ["code", "intent"];
+                                                readonly enum: readonly ["code", "source", "harness", "intent"];
                                             };
                                             readonly obligation: {
                                                 readonly type: "object";
@@ -638,13 +768,13 @@ export declare const upsertSpec: {
                     };
                     readonly operator: {
                         readonly type: "string";
-                        readonly enum: readonly ["eq", "neq", "lt", "lte", "gt", "gte"];
-                        readonly description: "Optional comparison operator for property_value facts. Example: 'eq'.";
+                        readonly enum: readonly ["eq", "neq", "lt", "lte", "gt", "gte", "matches", "includes", "subset_of", "excludes"];
+                        readonly description: "Optional comparison operator for property_value facts. Example: 'eq'. 'matches' (string facts only): value_string is a JavaScript regular expression (u flag) every value must match as a whole. Set facts only: 'includes' means every member of value_set has the property and other members may have it too; 'subset_of' means every member that has the property is in value_set ('every env var the server reads is one of ...'); 'excludes' means no member of value_set has it ('never imports md5'); 'eq' on a set means exactly those members.";
                     };
                     readonly value_type: {
                         readonly type: "string";
                         readonly enum: readonly ["string", "int", "number", "bool", "set"];
-                        readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, value_bool, or value_set (set: an exact list of allowed values, operator eq or neq); do not use generic value.";
+                        readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, value_bool, or value_set (set: a list of members, with operator eq, includes, subset_of or excludes); do not use generic value.";
                     };
                     readonly value_string: {
                         readonly type: "string";

package/dist/public/operations/specs/upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DuC,CAAC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DuC,CAAC"}

package/dist/public/proof-certificates.d.ts

@@ -1,9 +1,11 @@
 import { CODE_CERTIFICATE_VERSION } from "./proof-protocol.js";
+import { type SourceModel, type SourceSpec } from "./proof-sources.js";
+export type { SourceModel, SourceSpec } from "./proof-sources.js";
 /** Where `kibi prove` asks a run to leave its certificates. */
 export declare const PROOF_CERTIFICATES_ENV = "KIBI_PROOF_CERTIFICATES";
 export type CodeCertificate = Readonly<Record<string, unknown>> & Readonly<{
     version: typeof CODE_CERTIFICATE_VERSION;
-    kind: "exhaustive" | "typecheck" | "arithmetic" | "smt";
+    kind: "exhaustive" | "typecheck" | "arithmetic" | "smt" | "rule" | "state_machine" | "regex" | "source";
     test_id: string;
 }>;
 /**
@@ -81,6 +83,78 @@ export declare function smtCertificate(input: {
     query: string;
     result: string;
 }): CodeCertificate;
+/** A finite domain a rule certificate ranges over. */
+export type RuleDomain = Readonly<{
+    /** The domain's symbol; omit it for a domain the contract reads from a source. */
+    symbolId?: string;
+    members: Iterable<unknown>;
+}>;
+/** A predicate the code decides, and the argument types it takes. */
+export type RulePredicate = Readonly<{
+    symbolId: string;
+    argTypes: readonly string[];
+    decide: (...args: never[]) => boolean | Promise<boolean>;
+}>;
+/**
+ * Call every predicate on every combination of its argument domains and
+ * record what the code decides. Import the domains and functions from their
+ * source (never restate them): Kibi evaluates the same exports at ingest and
+ * rejects a certificate whose tables differ, then model checks each claim's
+ * rule, predicate or set fact against the tables.
+ */
+export declare function ruleCertificate(input: {
+    testId: string;
+    domains: Readonly<Record<string, RuleDomain>>;
+    predicates: Readonly<Record<string, RulePredicate>>;
+}): Promise<CodeCertificate>;
+/** The calls of a rule certificate that threw or returned a non-boolean. */
+export declare function failedCalls(certificate: CodeCertificate): string[];
+type Transitions = ReadonlyMap<unknown, unknown> | Readonly<Record<string, unknown>> | readonly unknown[] | ((state: never, event: never) => unknown);
+/**
+ * Record a state machine as the code defines it: a transition table (an
+ * object or Map from each state to its next state, states, or event map; or
+ * a list of [from, to] pairs) or a next-state function called on every state
+ * and event (a throw, null or undefined means no transition). Kibi reads the
+ * same exports at ingest and checks each claim's transitions, reachability,
+ * initial and terminal states against the machine.
+ */
+export declare function stateMachineCertificate(input: {
+    testId: string;
+    symbolId: string;
+    transitions: Transitions;
+    /** For a next-state function: the states and events it is called on. */
+    states?: Iterable<unknown>;
+    events?: Iterable<unknown>;
+    initial?: unknown;
+}): Promise<CodeCertificate>;
+/**
+ * Record the pattern (a RegExp) or string constant a string claim is about.
+ * Kibi reads the same export at ingest and decides the claim exactly: a
+ * pattern's language against the fact's, or the string against the fact.
+ */
+export declare function regexCertificate(input: {
+    testId: string;
+    symbolId: string;
+    value: RegExp | string;
+}): CodeCertificate;
+/**
+ * The certificate of a source proof. Kibi reads the contract's source
+ * itself at ingest and stores its own read, so the run only names the test
+ * and, optionally, the source (which must be the contract's). A run may also
+ * leave nothing: a passed source proof needs no certificate from the test.
+ */
+export declare function sourceCertificate(input: {
+    testId: string;
+    source?: SourceSpec;
+}): CodeCertificate;
+/**
+ * Read a project source the way Kibi does at ingest: the members (and the
+ * tables, objects or routes) of a JSON or YAML file, a glob, an OpenAPI
+ * document, the references the code makes, a data schema, a route table or
+ * a validator. A rule proof whose contract reads a domain from a source
+ * uses this to range its predicates over the same members.
+ */
+export declare function readProjectSource(source: SourceSpec, workspaceRoot?: string): Promise<SourceModel>;
 /**
  * Leave the certificate where `kibi prove` reads it. Returns the file written,
  * or null outside a `kibi prove` run.

package/dist/public/proof-certificates.d.ts.map

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