@pyric/cli 0.1.0-alpha.20 → 0.1.0-alpha.22

package/README.md

@@ -2,50 +2,39 @@
   <img src="https://pyric.dev/pyric-logo.svg" alt="Pyric" width="180" />
 </p>
 
-<h1 align="center">A local first Firebase development framework built for Agents</h1>
+<h1 align="center">A Firebase that runs inside your app</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>
+<p align="center">Keep the same <code>firebase/*</code> code. During <code>vite dev</code> those imports resolve to a local backend running in the page. A production build ships the real Firebase SDK, unchanged.</p>
 
 <p align="center"><a href="https://pyric.dev">pyric.dev</a></p>
 
 <br />
 
-Pyric adds a development-only resolution layer to a Firebase application. Run the Vite development server and supported Firebase imports resolve to a browser-local backend. Run a normal production build and those imports resolve to Firebase again. The application source does not branch between the two.
+Application code stays canonical Firebase:
 
-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 with a coding agent
-
-Install the Pyric plugin:
-
-```bash
-npx plugins add davideast/pyric
-```
-
-Antigravity CLI and OpenCode use the standalone skill installer:
+```ts
+// src/firebase.ts
+import { initializeApp } from 'firebase/app';
+import { getAuth } from 'firebase/auth';
+import { getFirestore } from 'firebase/firestore';
 
-```bash
-# Antigravity CLI
-npx skills add https://github.com/davideast/pyric/tree/main/pyric-plugin/skills/pyric --agent antigravity-cli
+const app = initializeApp({
+  apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
+  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
+  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
+});
 
-# OpenCode
-npx skills add https://github.com/davideast/pyric/tree/main/pyric-plugin/skills/pyric --agent opencode
+export const auth = getAuth(app);
+export const db = getFirestore(app);
 ```
 
-Then invoke the skill:
+Run the Vite development server and supported Firebase imports resolve to a browser-local backend: Auth, Firestore with Security Rules, persistence in IndexedDB, one SharedWorker backend shared by every tab on the dev origin. Run a normal production build and those imports resolve to Firebase again. The application source does not branch between the two, and the local mirror never connects to a production project.
 
-| Agent | Enter |
-|---|---|
-| Codex | `$pyric` |
-| Claude Code | `/pyric:pyric` |
-| Antigravity CLI | `/pyric` |
-| OpenCode | `/pyric` |
+Coding agents get the same backend. A [skill](#start-with-a-coding-agent) sets up the sandbox end to end (`npx plugins add davideast/pyric`, then `/pyric`), and an opt-in MCP bridge lets an agent seed, inspect, and change the backend the app is already running against. `can-i-use` answers what conforms to real Firebase before the agent builds on it.
 
-The leading `$` or `/` is part of the command.
-
-The skill chooses the project launcher, starts one local sandbox bridge, opens the application, and confirms that the browser sandbox is connected.
+<img width="1512" height="947" alt="Pyric Studio showing local data, requests, authentication state, and Security Rules verdicts" src="https://github.com/user-attachments/assets/cb4a219c-c5f0-4fb7-8904-996416c0a79c" />
 
-## Start from the terminal
+## Create a new app
 
 Create a Vite application with canonical Firebase imports, Firestore rules, and the Pyric development plugin already configured:
 
@@ -82,70 +71,69 @@ Start the normal development server:
 npm run dev
 ```
 
-During `vite dev`, the plugin swaps supported `firebase/*` modules at resolution time. The backend runs in a SharedWorker, so tabs on the same development origin use one local backend. Browser-local persistence uses IndexedDB.
-
-Pyric Studio is available on the Vite origin at `/__pyric/ui/studio`. It opens the same backend used by the application.
+During `vite dev`, the plugin swaps supported `firebase/*` modules at resolution time. Pyric Studio is available on the Vite origin at `/__pyric/ui/studio`. It opens the same backend used by the application.
 
 For a static application or a Node process, `pyric sandbox` provides the same development-only package swap without the Vite plugin. The [CLI reference](packages/site-docs/src/content/reference/cli.md) documents those paths and every command.
 
-## Keep using official Firebase SDKs
-
-Application code continues to import Firebase:
-
-```ts
-// src/firebase.ts
-import { initializeApp } from 'firebase/app';
-import { getAuth } from 'firebase/auth';
-import { getFirestore } from 'firebase/firestore';
+## Start with a coding agent
 
-const app = initializeApp({
-  apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
-  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
-  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
-});
+Install the Pyric plugin:
 
-export const auth = getAuth(app);
-export const db = getFirestore(app);
+```bash
+npx plugins add davideast/pyric
 ```
 
-The Firebase configuration is accepted by the local mirror during development. The production build passes that same configuration to Firebase. Normal Auth, Firestore, Realtime Database, Storage, Messaging, and Firebase AI Logic usage still belongs in the [Firebase documentation](https://firebase.google.com/docs).
+Antigravity CLI and OpenCode use the standalone skill installer:
 
-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.
+```bash
+# Antigravity CLI
+npx skills add https://github.com/davideast/pyric/tree/main/pyric-plugin/skills/pyric --agent antigravity-cli
 
-## Monitor the local environment in Pyric Studio
+# OpenCode
+npx skills add https://github.com/davideast/pyric/tree/main/pyric-plugin/skills/pyric --agent opencode
+```
 
-Pyric Studio shows local data, requests, authentication state, Security Rules verdicts, and denied operations. Open `/__pyric/ui/studio` 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.
+Then invoke the skill:
 
-<img width="1512" height="947" alt="image" src="https://github.com/user-attachments/assets/cb4a219c-c5f0-4fb7-8904-996416c0a79c" />
+| Agent | Enter |
+|---|---|
+| Codex | `$pyric` |
+| Claude Code | `/pyric:pyric` |
+| Antigravity CLI | `/pyric` |
+| OpenCode | `/pyric` |
 
-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.
+The leading `$` or `/` is part of the command.
 
-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:
+The skill chooses the project launcher, starts one local sandbox bridge, opens the application, and confirms that the browser sandbox is connected.
+
+An agent can also work through the MCP bridge directly. It keeps writing the same Firebase code while inspecting and changing the backend the application is already using. Agent access is opt-in:
 
 ```ts
 pyric({
-  persist: true,
-  seed: 'seed.json',
+  bridge: true
 });
 ```
 
-See [persistence and multi-tab behavior](packages/cli/docs/how-to/serve-persistence-and-multi-tab.md) for reset and seed precedence.
+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.
+
+## Monitor the local environment in Pyric Studio
+
+Pyric Studio shows local data, requests, authentication state, Security Rules verdicts, and denied operations. Open `/__pyric/ui/studio` 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.
 
-## Connect Coding Agents to the Sandbox using the Pyric MCP server
+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.
 
-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:
+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
-pyric({ 
-  bridge: true 
+pyric({
+  persist: true,
+  seed: 'seed.json',
 });
 ```
 
-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.
+See [persistence and multi-tab behavior](packages/site-docs/src/content/observe/shape-your-data.md) for reset and seed precedence.
 
-## Verify the rules against production 
+## 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:
 
@@ -153,7 +141,7 @@ Development sessions capture Firestore and Realtime Database operations in `.pyr
 npx pyric verify
 ```
 
-The default engine runs locally. The optional Firestore Rules Test API engine sends derived rule cases to Google's hosted evaluator when production-authority verification is needed. It verifies rules and does not deploy them. See [verify against a captured session](packages/cli/docs/how-to/verify-against-a-captured-session.md).
+The default engine runs locally. The optional Firestore Rules Test API engine sends derived rule cases to Google's hosted evaluator when production-authority verification is needed. It verifies rules and does not deploy them. See [verify against a captured session](packages/site-docs/src/content/ship/ship-to-production.md).
 
 ## Ship the same application code
 
@@ -165,37 +153,24 @@ npm run build
 
 The built application contains the real Firebase SDK and uses the Firebase configuration already present in the source. Deploy the build, rules, and indexes with `firebase-tools` or the Firebase Console. Pyric has no production deployment path.
 
+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.
+
+Normal Auth, Firestore, Realtime Database, Storage, Messaging, and Firebase AI Logic usage still belongs in the [Firebase documentation](https://firebase.google.com/docs). Pyric documents the parts that differ locally, including supported behavior, Security Rules, persistence, inspection, verification, and known gaps. See [use the Vite plugin](packages/site-docs/src/content/get-started/vite.md) for the complete plugin contract.
+
 ## Check what Pyric mirrors
 
 Pyric is an independent implementation of observable Firebase behavior. Conformance evidence records what has been compared with Firebase and keeps five outcomes distinct: conforms, documented divergence, bug, unsupported, and unverified. The evidence is a floor, not a claim that every Firebase behavior has been measured.
 
-Ask about a developer-facing feature without nesting discovery under rules verification:
+Ask about a developer-facing feature:
 
 ```bash
 npx pyric can-i-use getAfter
 npx pyric can-i-use firestore-rules/request.query --json
 ```
 
-The result reports availability, Firebase fidelity, and assurance eligibility as separate axes. Exact names succeed; a name shared by multiple surfaces asks you to qualify it, and fuzzy input prints labeled suggestions and exits nonzero instead of presenting a guess as a trust answer.
-
-Documentation and other Node consumers can bind the same feature name to the
-published import that exposes it, without maintaining a second surface map:
-
-```ts
-import { canIUse, canIUseImport } from '@pyric/cli/conformance';
-
-const result = canIUse('getDownloadURL', { importPath: 'pyric/storage' });
-const evidence = canIUseImport('pyric/storage');
-const evidencePage = evidence && `/docs/${evidence.evidenceSlug}/`;
-```
-
-Each support result carries only census-proven `importPaths`; registry ownership
-cannot invent package exports. `canIUseImport()` supplies the separate canonical
-import-to-evidence join used by generated API documentation. An unrelated
-import path returns no exact match rather than borrowing another surface's trust
-claim.
+The result reports availability, Firebase fidelity, and assurance eligibility as separate axes. Exact names succeed; fuzzy input prints labeled suggestions and exits nonzero instead of presenting a guess as a trust answer.
 
-Read the generated [conformance scores](https://pyric.dev/docs/conformance-scores/) and the service matrices in the site's Conformance section. They are built from the same canonical registry used by assurance and `canIUse`, without committing duplicate Markdown. The [versioning and compatibility policy](packages/pyric/docs/explanation/versioning-and-compatibility.md) explains the release boundary.
+Read the generated [conformance scores](https://pyric.dev/docs/conformance-scores/) and the service matrices in the site's Conformance section. They are built from the same canonical registry used by assurance and `canIUse`. Node consumers can query the same registry through [`@pyric/cli/conformance`](packages/site-docs/src/content/reference/cli.md). The [versioning and compatibility policy](packages/site-docs/src/content/trust/versioning-and-compatibility.md) explains the release boundary.
 
 ## Stability
 
@@ -212,4 +187,4 @@ bun run test
 bun run compat:check
 ```
 
-See [CONTRIBUTING.md](CONTRIBUTING.md), [CONTEXT.md](CONTEXT.md), and [AGENTS.md](AGENTS.md) before changing the codebase.
+See [CONTEXT.md](CONTEXT.md) and [AGENTS.md](AGENTS.md) before changing the codebase.

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

@@ -393,6 +393,136 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore#97": "supported";
     readonly "firestore#98": "supported";
     readonly "firestore#99": "supported";
+    readonly "firestore-flutter#1": "supported";
+    readonly "firestore-flutter#10": "qualified";
+    readonly "firestore-flutter#11": "supported";
+    readonly "firestore-flutter#12": "qualified";
+    readonly "firestore-flutter#13": "qualified";
+    readonly "firestore-flutter#14": "supported";
+    readonly "firestore-flutter#15": "supported";
+    readonly "firestore-flutter#16": "supported";
+    readonly "firestore-flutter#17": "supported";
+    readonly "firestore-flutter#18": "supported";
+    readonly "firestore-flutter#19": "supported";
+    readonly "firestore-flutter#2": "supported";
+    readonly "firestore-flutter#20": "supported";
+    readonly "firestore-flutter#21": "supported";
+    readonly "firestore-flutter#22": "supported";
+    readonly "firestore-flutter#23": "supported";
+    readonly "firestore-flutter#24": "supported";
+    readonly "firestore-flutter#25": "supported";
+    readonly "firestore-flutter#26": "supported";
+    readonly "firestore-flutter#27": "supported";
+    readonly "firestore-flutter#28": "supported";
+    readonly "firestore-flutter#29": "supported";
+    readonly "firestore-flutter#3": "supported";
+    readonly "firestore-flutter#30": "supported";
+    readonly "firestore-flutter#31": "supported";
+    readonly "firestore-flutter#32": "supported";
+    readonly "firestore-flutter#33": "supported";
+    readonly "firestore-flutter#34": "supported";
+    readonly "firestore-flutter#35": "supported";
+    readonly "firestore-flutter#36": "supported";
+    readonly "firestore-flutter#37": "supported";
+    readonly "firestore-flutter#38": "supported";
+    readonly "firestore-flutter#39": "supported";
+    readonly "firestore-flutter#4": "supported";
+    readonly "firestore-flutter#40": "supported";
+    readonly "firestore-flutter#41": "supported";
+    readonly "firestore-flutter#42": "supported";
+    readonly "firestore-flutter#43": "supported";
+    readonly "firestore-flutter#44": "supported";
+    readonly "firestore-flutter#45": "supported";
+    readonly "firestore-flutter#46": "supported";
+    readonly "firestore-flutter#47": "supported";
+    readonly "firestore-flutter#48": "supported";
+    readonly "firestore-flutter#49": "supported";
+    readonly "firestore-flutter#5": "supported";
+    readonly "firestore-flutter#50": "supported";
+    readonly "firestore-flutter#51": "supported";
+    readonly "firestore-flutter#52": "supported";
+    readonly "firestore-flutter#53": "qualified";
+    readonly "firestore-flutter#54": "supported";
+    readonly "firestore-flutter#55": "supported";
+    readonly "firestore-flutter#56": "supported";
+    readonly "firestore-flutter#57": "supported";
+    readonly "firestore-flutter#58": "supported";
+    readonly "firestore-flutter#59": "supported";
+    readonly "firestore-flutter#6": "supported";
+    readonly "firestore-flutter#60": "supported";
+    readonly "firestore-flutter#61": "supported";
+    readonly "firestore-flutter#62": "supported";
+    readonly "firestore-flutter#63": "supported";
+    readonly "firestore-flutter#64": "supported";
+    readonly "firestore-flutter#65": "supported";
+    readonly "firestore-flutter#7": "supported";
+    readonly "firestore-flutter#8": "supported";
+    readonly "firestore-flutter#9": "qualified";
+    readonly "firestore-kotlin#1": "supported";
+    readonly "firestore-kotlin#10": "qualified";
+    readonly "firestore-kotlin#11": "supported";
+    readonly "firestore-kotlin#12": "qualified";
+    readonly "firestore-kotlin#13": "qualified";
+    readonly "firestore-kotlin#14": "supported";
+    readonly "firestore-kotlin#15": "supported";
+    readonly "firestore-kotlin#16": "supported";
+    readonly "firestore-kotlin#17": "supported";
+    readonly "firestore-kotlin#18": "supported";
+    readonly "firestore-kotlin#19": "supported";
+    readonly "firestore-kotlin#2": "supported";
+    readonly "firestore-kotlin#20": "supported";
+    readonly "firestore-kotlin#21": "supported";
+    readonly "firestore-kotlin#22": "supported";
+    readonly "firestore-kotlin#23": "supported";
+    readonly "firestore-kotlin#24": "supported";
+    readonly "firestore-kotlin#25": "supported";
+    readonly "firestore-kotlin#26": "supported";
+    readonly "firestore-kotlin#27": "supported";
+    readonly "firestore-kotlin#28": "supported";
+    readonly "firestore-kotlin#29": "supported";
+    readonly "firestore-kotlin#3": "supported";
+    readonly "firestore-kotlin#30": "supported";
+    readonly "firestore-kotlin#31": "supported";
+    readonly "firestore-kotlin#32": "supported";
+    readonly "firestore-kotlin#33": "supported";
+    readonly "firestore-kotlin#34": "supported";
+    readonly "firestore-kotlin#35": "supported";
+    readonly "firestore-kotlin#36": "supported";
+    readonly "firestore-kotlin#37": "supported";
+    readonly "firestore-kotlin#38": "supported";
+    readonly "firestore-kotlin#39": "supported";
+    readonly "firestore-kotlin#4": "supported";
+    readonly "firestore-kotlin#40": "supported";
+    readonly "firestore-kotlin#41": "supported";
+    readonly "firestore-kotlin#42": "supported";
+    readonly "firestore-kotlin#43": "supported";
+    readonly "firestore-kotlin#44": "supported";
+    readonly "firestore-kotlin#45": "supported";
+    readonly "firestore-kotlin#46": "supported";
+    readonly "firestore-kotlin#47": "supported";
+    readonly "firestore-kotlin#48": "supported";
+    readonly "firestore-kotlin#49": "supported";
+    readonly "firestore-kotlin#5": "supported";
+    readonly "firestore-kotlin#50": "supported";
+    readonly "firestore-kotlin#51": "supported";
+    readonly "firestore-kotlin#52": "supported";
+    readonly "firestore-kotlin#53": "qualified";
+    readonly "firestore-kotlin#54": "supported";
+    readonly "firestore-kotlin#55": "supported";
+    readonly "firestore-kotlin#56": "supported";
+    readonly "firestore-kotlin#57": "supported";
+    readonly "firestore-kotlin#58": "supported";
+    readonly "firestore-kotlin#59": "supported";
+    readonly "firestore-kotlin#6": "supported";
+    readonly "firestore-kotlin#60": "supported";
+    readonly "firestore-kotlin#61": "supported";
+    readonly "firestore-kotlin#62": "supported";
+    readonly "firestore-kotlin#63": "supported";
+    readonly "firestore-kotlin#64": "supported";
+    readonly "firestore-kotlin#65": "supported";
+    readonly "firestore-kotlin#7": "supported";
+    readonly "firestore-kotlin#8": "supported";
+    readonly "firestore-kotlin#9": "qualified";
     readonly "firestore-rules#160": "supported";
     readonly "firestore-rules#161": "supported";
     readonly "firestore-rules#162": "supported";
@@ -425,6 +555,111 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore-rules#189": "supported";
     readonly "firestore-rules#190": "supported";
     readonly "firestore-rules#191": "supported";
+    readonly "firestore-swift#1": "supported";
+    readonly "firestore-swift#10": "supported";
+    readonly "firestore-swift#100": "supported";
+    readonly "firestore-swift#101": "supported";
+    readonly "firestore-swift#102": "supported";
+    readonly "firestore-swift#103": "qualified";
+    readonly "firestore-swift#104": "qualified";
+    readonly "firestore-swift#105": "qualified";
+    readonly "firestore-swift#11": "supported";
+    readonly "firestore-swift#12": "supported";
+    readonly "firestore-swift#13": "supported";
+    readonly "firestore-swift#14": "supported";
+    readonly "firestore-swift#15": "qualified";
+    readonly "firestore-swift#16": "qualified";
+    readonly "firestore-swift#17": "supported";
+    readonly "firestore-swift#18": "qualified";
+    readonly "firestore-swift#19": "qualified";
+    readonly "firestore-swift#2": "supported";
+    readonly "firestore-swift#20": "qualified";
+    readonly "firestore-swift#21": "qualified";
+    readonly "firestore-swift#22": "supported";
+    readonly "firestore-swift#23": "supported";
+    readonly "firestore-swift#24": "supported";
+    readonly "firestore-swift#25": "supported";
+    readonly "firestore-swift#26": "supported";
+    readonly "firestore-swift#27": "supported";
+    readonly "firestore-swift#28": "supported";
+    readonly "firestore-swift#29": "supported";
+    readonly "firestore-swift#3": "supported";
+    readonly "firestore-swift#30": "supported";
+    readonly "firestore-swift#31": "supported";
+    readonly "firestore-swift#32": "supported";
+    readonly "firestore-swift#33": "supported";
+    readonly "firestore-swift#34": "supported";
+    readonly "firestore-swift#35": "supported";
+    readonly "firestore-swift#36": "supported";
+    readonly "firestore-swift#37": "supported";
+    readonly "firestore-swift#38": "supported";
+    readonly "firestore-swift#39": "supported";
+    readonly "firestore-swift#4": "supported";
+    readonly "firestore-swift#40": "supported";
+    readonly "firestore-swift#41": "supported";
+    readonly "firestore-swift#42": "supported";
+    readonly "firestore-swift#43": "supported";
+    readonly "firestore-swift#44": "supported";
+    readonly "firestore-swift#45": "supported";
+    readonly "firestore-swift#46": "supported";
+    readonly "firestore-swift#47": "supported";
+    readonly "firestore-swift#48": "supported";
+    readonly "firestore-swift#49": "supported";
+    readonly "firestore-swift#5": "supported";
+    readonly "firestore-swift#50": "supported";
+    readonly "firestore-swift#51": "supported";
+    readonly "firestore-swift#52": "supported";
+    readonly "firestore-swift#53": "supported";
+    readonly "firestore-swift#54": "supported";
+    readonly "firestore-swift#55": "supported";
+    readonly "firestore-swift#56": "supported";
+    readonly "firestore-swift#57": "supported";
+    readonly "firestore-swift#58": "supported";
+    readonly "firestore-swift#59": "supported";
+    readonly "firestore-swift#6": "supported";
+    readonly "firestore-swift#60": "supported";
+    readonly "firestore-swift#61": "supported";
+    readonly "firestore-swift#62": "supported";
+    readonly "firestore-swift#63": "supported";
+    readonly "firestore-swift#64": "supported";
+    readonly "firestore-swift#65": "supported";
+    readonly "firestore-swift#66": "supported";
+    readonly "firestore-swift#67": "supported";
+    readonly "firestore-swift#68": "supported";
+    readonly "firestore-swift#69": "supported";
+    readonly "firestore-swift#7": "supported";
+    readonly "firestore-swift#70": "supported";
+    readonly "firestore-swift#71": "supported";
+    readonly "firestore-swift#72": "supported";
+    readonly "firestore-swift#73": "supported";
+    readonly "firestore-swift#74": "supported";
+    readonly "firestore-swift#75": "supported";
+    readonly "firestore-swift#76": "supported";
+    readonly "firestore-swift#77": "supported";
+    readonly "firestore-swift#78": "supported";
+    readonly "firestore-swift#79": "supported";
+    readonly "firestore-swift#8": "supported";
+    readonly "firestore-swift#80": "supported";
+    readonly "firestore-swift#81": "supported";
+    readonly "firestore-swift#82": "supported";
+    readonly "firestore-swift#83": "supported";
+    readonly "firestore-swift#84": "supported";
+    readonly "firestore-swift#85": "supported";
+    readonly "firestore-swift#86": "supported";
+    readonly "firestore-swift#87": "supported";
+    readonly "firestore-swift#88": "supported";
+    readonly "firestore-swift#89": "supported";
+    readonly "firestore-swift#9": "supported";
+    readonly "firestore-swift#90": "supported";
+    readonly "firestore-swift#91": "supported";
+    readonly "firestore-swift#92": "supported";
+    readonly "firestore-swift#93": "supported";
+    readonly "firestore-swift#94": "supported";
+    readonly "firestore-swift#95": "supported";
+    readonly "firestore-swift#96": "supported";
+    readonly "firestore-swift#97": "supported";
+    readonly "firestore-swift#98": "supported";
+    readonly "firestore-swift#99": "supported";
     readonly "firestore.binding.path-variable": "supported";
     readonly "firestore.binding.request": "supported";
     readonly "firestore.binding.request.auth": "supported";
@@ -446,7 +681,7 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "firestore.function.cast.int": "supported";
     readonly "firestore.function.cast.path": "supported";
     readonly "firestore.function.cast.string": "supported";
-    readonly "firestore.function.debug": "unsupported";
+    readonly "firestore.function.debug": "supported";
     readonly "firestore.function.duration.abs": "supported";
     readonly "firestore.function.duration.time": "supported";
     readonly "firestore.function.duration.value": "supported";
@@ -1061,6 +1296,8 @@ export declare const CONFORMANCE_VERDICTS: {
     readonly "storage-rules#130": "supported";
     readonly "storage-rules#131": "supported";
     readonly "storage-rules#132": "supported";
+    readonly "storage-rules#133": "supported";
+    readonly "storage-rules#134": "supported";
     readonly "storage-rules#94": "supported";
     readonly "storage-rules#95": "supported";
     readonly "storage-rules#96": "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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAinCgC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA81CgC,CAAC"}