proofreader-api

What this skill does

# Proofreader API

## Procedures

**Step 1: Identify the browser integration surface**
1. Inspect the workspace for browser entry points, editor or form UI handlers, and any existing built-in AI abstraction layer.
2. Execute `node scripts/find-proofreader-targets.mjs .` to inventory likely frontend files and existing Proofreader API markers when a Node runtime is available.
3. If a Node runtime is unavailable, inspect the nearest `package.json`, HTML entry point, and framework bootstrap files manually to identify the browser app boundary.
4. If the workspace contains multiple frontend apps, prefer the app that contains the active text-entry route, editor component, or user-requested proofreading surface.
5. If the inventory still leaves multiple plausible frontend targets, stop and ask which app should receive the Proofreader API integration.
6. If the project is not a browser web app, stop and explain that this skill does not apply.

**Step 2: Confirm API viability and option shape**
1. Read `references/proofreader-reference.md` before writing code.
2. Read `references/examples.md` when the feature needs session creation, download monitoring, result rendering, or quota-aware preflight.
3. Read `references/compatibility.md` when preview flags, browser channels, hardware requirements, iframe constraints, or browser-specific option gaps matter.
4. Read `references/troubleshooting.md` when feature detection, availability, creation, or proofreading fails.
5. Verify that the feature runs in a secure `Window` context and that the current frame is allowed to use the `proofreader` permissions-policy feature.
6. Match `availability()` and `create()` option shapes exactly, especially for `expectedInputLanguages`, `includeCorrectionTypes`, `includeCorrectionExplanations`, and `correctionExplanationLanguage` when the target browser supports them.
7. If the feature must run in a worker, on the server, or through a generic text-generation interface, stop and explain the platform mismatch.
8. If the project uses TypeScript, add or preserve typings that cover only the Proofreader API surface actually used by the feature.

**Step 3: Implement a guarded proofreader wrapper**
1. Read `assets/proofreader-session.template.ts` and adapt it to the framework, state model, and file layout in the workspace.
2. Gate session creation behind `Proofreader.availability()` using the same non-transient create options that the runtime session will use.
3. Treat `availability()` as a capability check, not a guarantee that creation will succeed without user activation, download time, or policy approval.
4. Create sessions only after user activation when the target browser may need to start a model download.
5. Use the `monitor` option during `create()` when the UI needs download progress.
6. Use `AbortController` for cancelable create or proofread calls, and call `destroy()` when the proofreading UI no longer needs the session.
7. Recreate the session instead of mutating option-dependent behavior after creation; session options are fixed per instance.
8. If the task requires correction labels or explanations, keep browser-specific fallbacks explicit instead of assuming every preview implements the full specification option set.

**Step 4: Wire UX and result handling**
1. Surface distinct states for missing APIs, unavailable devices, downloadable or downloading models, ready sessions, in-flight proofreading, canceled work, and hard failures.
2. Keep a non-AI fallback for unsupported browsers, blocked frames, or devices that do not meet the current preview requirements.
3. Render both `correctedInput` and the structured `corrections` array when the product needs visible diffs or selective acceptance.
4. Use `measureInputUsage()` before expensive proofreading only when the feature needs quota-aware behavior or large-input preflight.
5. Keep expected input languages explicit when the feature depends on supported language routing.
6. Do not use Proofreader as a general chat, summarization, or rewriting surface; switch to the correct built-in API when the task is not proofreading.

**Step 5: Validate behavior**
1. Execute `node scripts/find-proofreader-targets.mjs .` to confirm that the intended app boundary and Proofreader markers still resolve to the edited integration surface.
2. Verify feature detection, secure-context checks, permissions-policy access, and `availability()` behavior before debugging deeper runtime failures.
3. Test session creation with the exact options used in production, including download progress handling when the environment needs an initial model download.
4. Confirm that `proofread()` returns the expected `correctedInput` and correction ranges for representative user text.
5. If the integration uses `measureInputUsage()`, confirm that large inputs are rejected or trimmed before the browser throws quota-related failures.
6. Confirm that cancellation stops work cleanly and that destroyed sessions are not reused.
7. If the target environment depends on preview flags, origin trials, or channel-specific behavior, confirm the required browser state from `references/compatibility.md` before treating failures as application bugs.
8. Run the workspace build, typecheck, or tests after editing.

## Error Handling
* If `Proofreader` is missing, keep a non-AI fallback and confirm that the environment satisfies the secure-context, browser, and preview requirements before changing product logic.
* If `availability()` returns `downloadable` or `downloading`, require user-driven session creation before promising that proofreading is ready.
* If `create()` or `proofread()` throws `NotAllowedError`, check permissions-policy constraints, missing user activation for downloads, browser policy restrictions, or user rejection.
* If `create()` or `proofread()` throws `NotSupportedError`, align the requested languages and option set with the browser's supported combinations and remove unsupported preview-only assumptions.
* If creation fails with `OperationError`, `UnknownError`, or another runtime exception, retry once only after confirming that device eligibility, storage, and browser flags still match `references/compatibility.md`.
* If the feature must run in a worker or server context, stop and explain that the Proofreader API is a window-only browser API.