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

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>
 
@@ -38,7 +38,7 @@ 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()],
@@ -57,7 +57,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 +81,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 +100,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",