@pyric/cli 0.1.0-alpha.16 → 0.1.0-alpha.18

package/README.md

@@ -2,7 +2,7 @@
   <img src="https://pyric.dev/pyric-logo.svg" alt="Pyric" width="180" />
 </p>
 
-<h1 align="center">Build with Firebase without touching production</h1>
+<h1 align="center">A local first Firebase development framework built for Agents</h1>
 
 <p align="center">Keep the same <code>firebase/*</code> code. Pyric runs it against a local backend during development, then gets out of the way when the app ships to Firebase.</p>
 
@@ -14,12 +14,38 @@ Pyric adds a development-only resolution layer to a Firebase application. Run th
 
 The mirrored data services do not connect to a production Firebase project. Local writes cannot delete production data or create Firebase usage charges, and local rules changes do not deploy. Pyric owns the development sandbox and verification workflow. Firebase owns production, with `firebase-tools` or the Firebase Console handling deployment.
 
-## Start a new Firebase application locally
+## Start with a coding agent
+
+Install the Pyric plugin:
+
+```bash
+npx plugins add davideast/pyric
+```
+
+Antigravity CLI and OpenCode use the standalone skill installer:
+
+```bash
+# Antigravity CLI
+npx skills add https://github.com/davideast/pyric/tree/main/pyric-plugin/skills/pyric-start --agent antigravity-cli
+
+# OpenCode
+npx skills add https://github.com/davideast/pyric/tree/main/pyric-plugin/skills/pyric-start --agent opencode
+```
+
+Then ask your agent:
+
+```text
+Use the pyric-start skill to set up and run Pyric in this project.
+```
+
+The skill chooses the project launcher, starts one local sandbox bridge, opens the application, and confirms that the browser sandbox is connected.
+
+## Start from the terminal
 
 Create a Vite application with canonical Firebase imports, Firestore rules, and the Pyric development plugin already configured:
 
 ```bash
-npm create pyric my-app
+npm create pyric@latest my-app
 cd my-app
 npm install
 npm run dev
@@ -38,10 +64,10 @@ Add it to the existing Vite configuration:
 ```ts
 // vite.config.ts
 import { defineConfig } from 'vite';
-import { pyricSandbox } from '@pyric/cli/vite';
+import { pyric } from '@pyric/cli/vite';
 
 export default defineConfig({
-  plugins: [pyricSandbox()],
+  plugins: [pyric()],
 });
 ```
 
@@ -57,7 +83,7 @@ Pyric Studio is available on the Vite origin at `/__pyric/ui/`. It opens the sam
 
 For a static application or a Node process, `pyric dev` provides the same development-only package swap without the Vite plugin. The [CLI reference](packages/cli/docs/reference/cli.md) documents those paths and every command.
 
-## Keep writing Firebase code
+## Keep using official Firebase SDKs
 
 Application code continues to import Firebase:
 
@@ -81,16 +107,18 @@ The Firebase configuration is accepted by the local mirror during development. T
 
 Pyric documents the parts that differ locally, including supported behavior, Security Rules, persistence, inspection, verification, and known gaps. See [use the Vite plugin](packages/cli/docs/how-to/use-the-vite-plugin.md) for the complete plugin contract.
 
-## Inspect and correct a failed operation
+## Monitor the local environment in Pyric Studio
 
 Pyric Studio shows local data, requests, authentication state, Security Rules verdicts, and denied operations. Open `/__pyric/ui/` on the development server and reproduce the failure. A denied request includes the path and verdict needed to correct the rule or the application code.
 
+<img width="1512" height="947" alt="image" src="https://github.com/user-attachments/assets/cb4a219c-c5f0-4fb7-8904-996416c0a79c" />
+
 The Vite plugin discovers the Firestore rules path from `firebase.json`, or falls back to `firestore.rules`. Saving that file replaces the active local ruleset without a production deploy. A parse failure leaves the last valid ruleset active and reports the error in the development server.
 
 State and test identities stay browser-local by default. Add `persist: true` to write a committable `.pyric/state/state.json`, or use `seed` to start from a known scenario:
 
 ```ts
-pyricSandbox({
+pyric({
   persist: true,
   seed: 'seed.json',
 });
@@ -98,19 +126,21 @@ pyricSandbox({
 
 See [persistence and multi-tab behavior](packages/cli/docs/how-to/serve-persistence-and-multi-tab.md) for reset and seed precedence.
 
-## Give coding agents the same local Firebase target
+## Connect Coding Agents to the Sandbox using the Pyric MCP server
 
 An agent can keep writing the same Firebase code while inspecting and changing the backend that the application is already using. Agent access is opt-in. Enable the MCP bridge in the Vite plugin:
 
 ```ts
-pyricSandbox({ bridge: true });
+pyric({ 
+  bridge: true 
+});
 ```
 
-The bridge mounts on the Vite development origin and routes agent operations to the same SharedWorker backend used by the application and Studio. The included [Claude Code plugin](pyric-plugin/README.md) discovers that bridge, while other MCP clients can connect to its HTTP endpoint.
+The bridge mounts on the Vite development origin and routes agent operations to the same SharedWorker backend used by the application and Studio.
 
 This protects the local workflow, not an independently credentialed process. A coding agent with production Firebase credentials or deployment access can still affect production outside Pyric.
 
-## Verify the rules boundary
+## Verify the rules against production 
 
 Development sessions capture Firestore and Realtime Database operations in `.pyric/last-session.json` by default. Replay those requests against candidate rules before deployment:
 

package/dist/assurance/.generated/conformance-verdicts.d.ts

@@ -285,7 +285,13 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore#149": "qualified";
     readonly "firestore#15": "supported";
     readonly "firestore#150": "supported";
+    readonly "firestore#151": "supported";
     readonly "firestore#152": "supported";
+    readonly "firestore#153": "supported";
+    readonly "firestore#154": "supported";
+    readonly "firestore#155": "supported";
+    readonly "firestore#156": "supported";
+    readonly "firestore#157": "supported";
     readonly "firestore#16": "supported";
     readonly "firestore#17": "supported";
     readonly "firestore#18": "supported";
@@ -417,6 +423,8 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore-rules#187": "supported";
     readonly "firestore-rules#188": "supported";
     readonly "firestore-rules#189": "supported";
+    readonly "firestore-rules#190": "supported";
+    readonly "firestore-rules#191": "supported";
     readonly "firestore.binding.path-variable": "supported";
     readonly "firestore.binding.request": "supported";
     readonly "firestore.binding.request.auth": "supported";
@@ -433,7 +441,7 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore.binding.resource.__name__": "supported";
     readonly "firestore.binding.resource.data": "supported";
     readonly "firestore.binding.resource.id": "supported";
-    readonly "firestore.function.cast.bool": "unsupported";
+    readonly "firestore.function.cast.bool": "supported";
     readonly "firestore.function.cast.float": "supported";
     readonly "firestore.function.cast.int": "supported";
     readonly "firestore.function.cast.path": "supported";
@@ -454,7 +462,7 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore.function.math.abs": "supported";
     readonly "firestore.function.math.ceil": "supported";
     readonly "firestore.function.math.floor": "supported";
-    readonly "firestore.function.math.isInfinite": "unsupported";
+    readonly "firestore.function.math.isInfinite": "supported";
     readonly "firestore.function.math.isNaN": "supported";
     readonly "firestore.function.math.pow": "supported";
     readonly "firestore.function.math.round": "supported";
@@ -479,9 +487,9 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore.method.list.toSet": "supported";
     readonly "firestore.method.map.diff": "supported";
     readonly "firestore.method.map.get": "supported";
-    readonly "firestore.method.map.hasAll": "unsupported";
-    readonly "firestore.method.map.hasAny": "unsupported";
-    readonly "firestore.method.map.hasOnly": "unsupported";
+    readonly "firestore.method.map.hasAll": "supported";
+    readonly "firestore.method.map.hasAny": "supported";
+    readonly "firestore.method.map.hasOnly": "supported";
     readonly "firestore.method.map.keys": "supported";
     readonly "firestore.method.map.size": "supported";
     readonly "firestore.method.map.values": "supported";
@@ -871,62 +879,62 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "rtdb-rules#7": "supported";
     readonly "rtdb-rules#8": "supported";
     readonly "rtdb-rules#9": "supported";
-    readonly "rtdb.binding.auth": "qualified";
-    readonly "rtdb.binding.auth.token": "qualified";
-    readonly "rtdb.binding.auth.uid": "qualified";
-    readonly "rtdb.binding.data": "qualified";
-    readonly "rtdb.binding.newData": "qualified";
-    readonly "rtdb.binding.now": "qualified";
-    readonly "rtdb.binding.path-variable": "qualified";
-    readonly "rtdb.binding.root": "qualified";
-    readonly "rtdb.method.snapshot.child": "qualified";
-    readonly "rtdb.method.snapshot.exists": "qualified";
-    readonly "rtdb.method.snapshot.getPriority": "qualified";
-    readonly "rtdb.method.snapshot.hasChild": "qualified";
-    readonly "rtdb.method.snapshot.hasChildren": "qualified";
-    readonly "rtdb.method.snapshot.isBoolean": "qualified";
-    readonly "rtdb.method.snapshot.isNumber": "qualified";
-    readonly "rtdb.method.snapshot.isString": "qualified";
-    readonly "rtdb.method.snapshot.parent": "qualified";
-    readonly "rtdb.method.snapshot.val": "qualified";
-    readonly "rtdb.method.string.beginsWith": "qualified";
-    readonly "rtdb.method.string.contains": "qualified";
-    readonly "rtdb.method.string.endsWith": "qualified";
-    readonly "rtdb.method.string.length": "qualified";
-    readonly "rtdb.method.string.matches": "qualified";
-    readonly "rtdb.method.string.replace": "qualified";
-    readonly "rtdb.method.string.toLowerCase": "qualified";
-    readonly "rtdb.method.string.toUpperCase": "qualified";
-    readonly "rtdb.operator.add": "qualified";
-    readonly "rtdb.operator.and": "qualified";
-    readonly "rtdb.operator.div": "qualified";
-    readonly "rtdb.operator.gt": "qualified";
-    readonly "rtdb.operator.gte": "qualified";
-    readonly "rtdb.operator.index": "qualified";
-    readonly "rtdb.operator.looseEq": "qualified";
-    readonly "rtdb.operator.looseNeq": "qualified";
-    readonly "rtdb.operator.lt": "qualified";
-    readonly "rtdb.operator.lte": "qualified";
-    readonly "rtdb.operator.member": "qualified";
-    readonly "rtdb.operator.mod": "qualified";
-    readonly "rtdb.operator.mul": "qualified";
-    readonly "rtdb.operator.neg": "qualified";
-    readonly "rtdb.operator.not": "qualified";
-    readonly "rtdb.operator.or": "qualified";
-    readonly "rtdb.operator.strictEq": "qualified";
-    readonly "rtdb.operator.strictNeq": "qualified";
-    readonly "rtdb.operator.sub": "qualified";
-    readonly "rtdb.operator.ternary": "qualified";
-    readonly "rtdb.rule-kind.indexOn": "qualified";
-    readonly "rtdb.rule-kind.location-wildcard": "qualified";
-    readonly "rtdb.rule-kind.read": "qualified";
-    readonly "rtdb.rule-kind.validate": "qualified";
-    readonly "rtdb.rule-kind.write": "qualified";
+    readonly "rtdb.binding.auth": "supported";
+    readonly "rtdb.binding.auth.token": "supported";
+    readonly "rtdb.binding.auth.uid": "supported";
+    readonly "rtdb.binding.data": "supported";
+    readonly "rtdb.binding.newData": "supported";
+    readonly "rtdb.binding.now": "supported";
+    readonly "rtdb.binding.path-variable": "supported";
+    readonly "rtdb.binding.root": "supported";
+    readonly "rtdb.method.snapshot.child": "supported";
+    readonly "rtdb.method.snapshot.exists": "supported";
+    readonly "rtdb.method.snapshot.getPriority": "supported";
+    readonly "rtdb.method.snapshot.hasChild": "supported";
+    readonly "rtdb.method.snapshot.hasChildren": "supported";
+    readonly "rtdb.method.snapshot.isBoolean": "supported";
+    readonly "rtdb.method.snapshot.isNumber": "supported";
+    readonly "rtdb.method.snapshot.isString": "supported";
+    readonly "rtdb.method.snapshot.parent": "supported";
+    readonly "rtdb.method.snapshot.val": "supported";
+    readonly "rtdb.method.string.beginsWith": "supported";
+    readonly "rtdb.method.string.contains": "supported";
+    readonly "rtdb.method.string.endsWith": "supported";
+    readonly "rtdb.method.string.length": "supported";
+    readonly "rtdb.method.string.matches": "supported";
+    readonly "rtdb.method.string.replace": "supported";
+    readonly "rtdb.method.string.toLowerCase": "supported";
+    readonly "rtdb.method.string.toUpperCase": "supported";
+    readonly "rtdb.operator.add": "supported";
+    readonly "rtdb.operator.and": "supported";
+    readonly "rtdb.operator.div": "supported";
+    readonly "rtdb.operator.gt": "supported";
+    readonly "rtdb.operator.gte": "supported";
+    readonly "rtdb.operator.index": "supported";
+    readonly "rtdb.operator.looseEq": "supported";
+    readonly "rtdb.operator.looseNeq": "supported";
+    readonly "rtdb.operator.lt": "supported";
+    readonly "rtdb.operator.lte": "supported";
+    readonly "rtdb.operator.member": "supported";
+    readonly "rtdb.operator.mod": "supported";
+    readonly "rtdb.operator.mul": "supported";
+    readonly "rtdb.operator.neg": "supported";
+    readonly "rtdb.operator.not": "supported";
+    readonly "rtdb.operator.or": "supported";
+    readonly "rtdb.operator.strictEq": "supported";
+    readonly "rtdb.operator.strictNeq": "supported";
+    readonly "rtdb.operator.sub": "supported";
+    readonly "rtdb.operator.ternary": "supported";
+    readonly "rtdb.rule-kind.indexOn": "supported";
+    readonly "rtdb.rule-kind.location-wildcard": "supported";
+    readonly "rtdb.rule-kind.read": "supported";
+    readonly "rtdb.rule-kind.validate": "supported";
+    readonly "rtdb.rule-kind.write": "supported";
     readonly "rtdb.semantic.deny-by-default": "qualified";
-    readonly "rtdb.semantic.read-cascade": "qualified";
-    readonly "rtdb.semantic.regex-literal": "qualified";
-    readonly "rtdb.semantic.validate-non-cascade": "qualified";
-    readonly "rtdb.semantic.write-cascade": "qualified";
+    readonly "rtdb.semantic.read-cascade": "supported";
+    readonly "rtdb.semantic.regex-literal": "supported";
+    readonly "rtdb.semantic.validate-non-cascade": "supported";
+    readonly "rtdb.semantic.write-cascade": "supported";
     readonly "storage#1": "supported";
     readonly "storage#10": "supported";
     readonly "storage#105": "supported";
@@ -973,12 +981,12 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "storage#44": "supported";
     readonly "storage#45": "supported";
     readonly "storage#46": "supported";
-    readonly "storage#47": "unsupported";
-    readonly "storage#48": "unsupported";
-    readonly "storage#49": "unsupported";
+    readonly "storage#47": "qualified";
+    readonly "storage#48": "qualified";
+    readonly "storage#49": "qualified";
     readonly "storage#4a": "supported";
     readonly "storage#5": "supported";
-    readonly "storage#50": "unsupported";
+    readonly "storage#50": "qualified";
     readonly "storage#51": "qualified";
     readonly "storage#52": "supported";
     readonly "storage#53": "supported";
@@ -1089,30 +1097,30 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "storage.method.map.get": "supported";
     readonly "storage.method.map.keys": "supported";
     readonly "storage.method.set.hasAll": "supported";
-    readonly "storage.method.size": "qualified";
+    readonly "storage.method.size": "supported";
     readonly "storage.method.string.matches": "supported";
-    readonly "storage.method.string.split": "qualified";
+    readonly "storage.method.string.split": "supported";
     readonly "storage.operator.add": "supported";
     readonly "storage.operator.and": "supported";
     readonly "storage.operator.div": "supported";
     readonly "storage.operator.eq": "supported";
     readonly "storage.operator.gt": "supported";
     readonly "storage.operator.gte": "supported";
-    readonly "storage.operator.in": "qualified";
+    readonly "storage.operator.in": "supported";
     readonly "storage.operator.index": "supported";
-    readonly "storage.operator.is": "qualified";
+    readonly "storage.operator.is": "supported";
     readonly "storage.operator.lt": "supported";
     readonly "storage.operator.lte": "supported";
     readonly "storage.operator.member": "supported";
-    readonly "storage.operator.mod": "qualified";
+    readonly "storage.operator.mod": "supported";
     readonly "storage.operator.mul": "supported";
     readonly "storage.operator.neq": "supported";
     readonly "storage.operator.not": "supported";
     readonly "storage.operator.or": "supported";
-    readonly "storage.operator.slice": "qualified";
+    readonly "storage.operator.slice": "supported";
     readonly "storage.operator.sub": "supported";
-    readonly "storage.operator.ternary": "qualified";
-    readonly "storage.operator.unary-minus": "qualified";
+    readonly "storage.operator.ternary": "supported";
+    readonly "storage.operator.unary-minus": "supported";
     readonly "storage.rule-kind.allow-create": "supported";
     readonly "storage.rule-kind.allow-delete": "supported";
     readonly "storage.rule-kind.allow-get": "supported";

package/dist/assurance/.generated/conformance-verdicts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance-verdicts.d.ts","sourceRoot":"","sources":["../../../src/assurance/.generated/conformance-verdicts.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,WAAW,GAAG,aAAa,CAAC;AAE3E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAymCgC,CAAC"}
+{"version":3,"file":"conformance-verdicts.d.ts","sourceRoot":"","sources":["../../../src/assurance/.generated/conformance-verdicts.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,WAAW,GAAG,aAAa,CAAC;AAE3E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAinCgC,CAAC"}

package/dist/assurance/.generated/conformance-verdicts.js

@@ -284,7 +284,13 @@ export const CONFORMANCE_VERDICTS = {
     "firestore#149": "qualified",
     "firestore#15": "supported",
     "firestore#150": "supported",
+    "firestore#151": "supported",
     "firestore#152": "supported",
+    "firestore#153": "supported",
+    "firestore#154": "supported",
+    "firestore#155": "supported",
+    "firestore#156": "supported",
+    "firestore#157": "supported",
     "firestore#16": "supported",
     "firestore#17": "supported",
     "firestore#18": "supported",
@@ -416,6 +422,8 @@ export const CONFORMANCE_VERDICTS = {
     "firestore-rules#187": "supported",
     "firestore-rules#188": "supported",
     "firestore-rules#189": "supported",
+    "firestore-rules#190": "supported",
+    "firestore-rules#191": "supported",
     "firestore.binding.path-variable": "supported",
     "firestore.binding.request": "supported",
     "firestore.binding.request.auth": "supported",
@@ -432,7 +440,7 @@ export const CONFORMANCE_VERDICTS = {
     "firestore.binding.resource.__name__": "supported",
     "firestore.binding.resource.data": "supported",
     "firestore.binding.resource.id": "supported",
-    "firestore.function.cast.bool": "unsupported",
+    "firestore.function.cast.bool": "supported",
     "firestore.function.cast.float": "supported",
     "firestore.function.cast.int": "supported",
     "firestore.function.cast.path": "supported",
@@ -453,7 +461,7 @@ export const CONFORMANCE_VERDICTS = {
     "firestore.function.math.abs": "supported",
     "firestore.function.math.ceil": "supported",
     "firestore.function.math.floor": "supported",
-    "firestore.function.math.isInfinite": "unsupported",
+    "firestore.function.math.isInfinite": "supported",
     "firestore.function.math.isNaN": "supported",
     "firestore.function.math.pow": "supported",
     "firestore.function.math.round": "supported",
@@ -478,9 +486,9 @@ export const CONFORMANCE_VERDICTS = {
     "firestore.method.list.toSet": "supported",
     "firestore.method.map.diff": "supported",
     "firestore.method.map.get": "supported",
-    "firestore.method.map.hasAll": "unsupported",
-    "firestore.method.map.hasAny": "unsupported",
-    "firestore.method.map.hasOnly": "unsupported",
+    "firestore.method.map.hasAll": "supported",
+    "firestore.method.map.hasAny": "supported",
+    "firestore.method.map.hasOnly": "supported",
     "firestore.method.map.keys": "supported",
     "firestore.method.map.size": "supported",
     "firestore.method.map.values": "supported",
@@ -870,62 +878,62 @@ export const CONFORMANCE_VERDICTS = {
     "rtdb-rules#7": "supported",
     "rtdb-rules#8": "supported",
     "rtdb-rules#9": "supported",
-    "rtdb.binding.auth": "qualified",
-    "rtdb.binding.auth.token": "qualified",
-    "rtdb.binding.auth.uid": "qualified",
-    "rtdb.binding.data": "qualified",
-    "rtdb.binding.newData": "qualified",
-    "rtdb.binding.now": "qualified",
-    "rtdb.binding.path-variable": "qualified",
-    "rtdb.binding.root": "qualified",
-    "rtdb.method.snapshot.child": "qualified",
-    "rtdb.method.snapshot.exists": "qualified",
-    "rtdb.method.snapshot.getPriority": "qualified",
-    "rtdb.method.snapshot.hasChild": "qualified",
-    "rtdb.method.snapshot.hasChildren": "qualified",
-    "rtdb.method.snapshot.isBoolean": "qualified",
-    "rtdb.method.snapshot.isNumber": "qualified",
-    "rtdb.method.snapshot.isString": "qualified",
-    "rtdb.method.snapshot.parent": "qualified",
-    "rtdb.method.snapshot.val": "qualified",
-    "rtdb.method.string.beginsWith": "qualified",
-    "rtdb.method.string.contains": "qualified",
-    "rtdb.method.string.endsWith": "qualified",
-    "rtdb.method.string.length": "qualified",
-    "rtdb.method.string.matches": "qualified",
-    "rtdb.method.string.replace": "qualified",
-    "rtdb.method.string.toLowerCase": "qualified",
-    "rtdb.method.string.toUpperCase": "qualified",
-    "rtdb.operator.add": "qualified",
-    "rtdb.operator.and": "qualified",
-    "rtdb.operator.div": "qualified",
-    "rtdb.operator.gt": "qualified",
-    "rtdb.operator.gte": "qualified",
-    "rtdb.operator.index": "qualified",
-    "rtdb.operator.looseEq": "qualified",
-    "rtdb.operator.looseNeq": "qualified",
-    "rtdb.operator.lt": "qualified",
-    "rtdb.operator.lte": "qualified",
-    "rtdb.operator.member": "qualified",
-    "rtdb.operator.mod": "qualified",
-    "rtdb.operator.mul": "qualified",
-    "rtdb.operator.neg": "qualified",
-    "rtdb.operator.not": "qualified",
-    "rtdb.operator.or": "qualified",
-    "rtdb.operator.strictEq": "qualified",
-    "rtdb.operator.strictNeq": "qualified",
-    "rtdb.operator.sub": "qualified",
-    "rtdb.operator.ternary": "qualified",
-    "rtdb.rule-kind.indexOn": "qualified",
-    "rtdb.rule-kind.location-wildcard": "qualified",
-    "rtdb.rule-kind.read": "qualified",
-    "rtdb.rule-kind.validate": "qualified",
-    "rtdb.rule-kind.write": "qualified",
+    "rtdb.binding.auth": "supported",
+    "rtdb.binding.auth.token": "supported",
+    "rtdb.binding.auth.uid": "supported",
+    "rtdb.binding.data": "supported",
+    "rtdb.binding.newData": "supported",
+    "rtdb.binding.now": "supported",
+    "rtdb.binding.path-variable": "supported",
+    "rtdb.binding.root": "supported",
+    "rtdb.method.snapshot.child": "supported",
+    "rtdb.method.snapshot.exists": "supported",
+    "rtdb.method.snapshot.getPriority": "supported",
+    "rtdb.method.snapshot.hasChild": "supported",
+    "rtdb.method.snapshot.hasChildren": "supported",
+    "rtdb.method.snapshot.isBoolean": "supported",
+    "rtdb.method.snapshot.isNumber": "supported",
+    "rtdb.method.snapshot.isString": "supported",
+    "rtdb.method.snapshot.parent": "supported",
+    "rtdb.method.snapshot.val": "supported",
+    "rtdb.method.string.beginsWith": "supported",
+    "rtdb.method.string.contains": "supported",
+    "rtdb.method.string.endsWith": "supported",
+    "rtdb.method.string.length": "supported",
+    "rtdb.method.string.matches": "supported",
+    "rtdb.method.string.replace": "supported",
+    "rtdb.method.string.toLowerCase": "supported",
+    "rtdb.method.string.toUpperCase": "supported",
+    "rtdb.operator.add": "supported",
+    "rtdb.operator.and": "supported",
+    "rtdb.operator.div": "supported",
+    "rtdb.operator.gt": "supported",
+    "rtdb.operator.gte": "supported",
+    "rtdb.operator.index": "supported",
+    "rtdb.operator.looseEq": "supported",
+    "rtdb.operator.looseNeq": "supported",
+    "rtdb.operator.lt": "supported",
+    "rtdb.operator.lte": "supported",
+    "rtdb.operator.member": "supported",
+    "rtdb.operator.mod": "supported",
+    "rtdb.operator.mul": "supported",
+    "rtdb.operator.neg": "supported",
+    "rtdb.operator.not": "supported",
+    "rtdb.operator.or": "supported",
+    "rtdb.operator.strictEq": "supported",
+    "rtdb.operator.strictNeq": "supported",
+    "rtdb.operator.sub": "supported",
+    "rtdb.operator.ternary": "supported",
+    "rtdb.rule-kind.indexOn": "supported",
+    "rtdb.rule-kind.location-wildcard": "supported",
+    "rtdb.rule-kind.read": "supported",
+    "rtdb.rule-kind.validate": "supported",
+    "rtdb.rule-kind.write": "supported",
     "rtdb.semantic.deny-by-default": "qualified",
-    "rtdb.semantic.read-cascade": "qualified",
-    "rtdb.semantic.regex-literal": "qualified",
-    "rtdb.semantic.validate-non-cascade": "qualified",
-    "rtdb.semantic.write-cascade": "qualified",
+    "rtdb.semantic.read-cascade": "supported",
+    "rtdb.semantic.regex-literal": "supported",
+    "rtdb.semantic.validate-non-cascade": "supported",
+    "rtdb.semantic.write-cascade": "supported",
     "storage#1": "supported",
     "storage#10": "supported",
     "storage#105": "supported",
@@ -972,12 +980,12 @@ export const CONFORMANCE_VERDICTS = {
     "storage#44": "supported",
     "storage#45": "supported",
     "storage#46": "supported",
-    "storage#47": "unsupported",
-    "storage#48": "unsupported",
-    "storage#49": "unsupported",
+    "storage#47": "qualified",
+    "storage#48": "qualified",
+    "storage#49": "qualified",
     "storage#4a": "supported",
     "storage#5": "supported",
-    "storage#50": "unsupported",
+    "storage#50": "qualified",
     "storage#51": "qualified",
     "storage#52": "supported",
     "storage#53": "supported",
@@ -1088,30 +1096,30 @@ export const CONFORMANCE_VERDICTS = {
     "storage.method.map.get": "supported",
     "storage.method.map.keys": "supported",
     "storage.method.set.hasAll": "supported",
-    "storage.method.size": "qualified",
+    "storage.method.size": "supported",
     "storage.method.string.matches": "supported",
-    "storage.method.string.split": "qualified",
+    "storage.method.string.split": "supported",
     "storage.operator.add": "supported",
     "storage.operator.and": "supported",
     "storage.operator.div": "supported",
     "storage.operator.eq": "supported",
     "storage.operator.gt": "supported",
     "storage.operator.gte": "supported",
-    "storage.operator.in": "qualified",
+    "storage.operator.in": "supported",
     "storage.operator.index": "supported",
-    "storage.operator.is": "qualified",
+    "storage.operator.is": "supported",
     "storage.operator.lt": "supported",
     "storage.operator.lte": "supported",
     "storage.operator.member": "supported",
-    "storage.operator.mod": "qualified",
+    "storage.operator.mod": "supported",
     "storage.operator.mul": "supported",
     "storage.operator.neq": "supported",
     "storage.operator.not": "supported",
     "storage.operator.or": "supported",
-    "storage.operator.slice": "qualified",
+    "storage.operator.slice": "supported",
     "storage.operator.sub": "supported",
-    "storage.operator.ternary": "qualified",
-    "storage.operator.unary-minus": "qualified",
+    "storage.operator.ternary": "supported",
+    "storage.operator.unary-minus": "supported",
     "storage.rule-kind.allow-create": "supported",
     "storage.rule-kind.allow-delete": "supported",
     "storage.rule-kind.allow-get": "supported",