@file-viewer/ppt 0.3.0 → 0.3.2

package/LICENSE

@@ -1,196 +1,122 @@
-Flyfish Public Watermarked Binary License for @file-viewer/ppt
-Version 1.2, July 2026
-License policy identifier: flyfish-public-watermarked-binary-license-v1
+Flyfish Public Watermarked Runtime License for @file-viewer/ppt
+Version 2.0, July 2026
+License policy identifier: flyfish-public-watermarked-binary-license-v2
 
 Copyright (c) 2026 Flyfish. All rights reserved except as expressly granted in this License.
 
-IMPORTANT: This is a proprietary binary-use license. It is not an open-source
-license. By downloading, installing, copying, accessing, or using the Public
-Package, You accept this License. If You do not accept it, do not use the Public
-Package and delete every copy under Your control.
+IMPORTANT: This is a proprietary runtime license, not an open-source license.
+By downloading, installing, copying, accessing, or using the Public Runtime,
+You accept this License. If You do not accept it, do not use the Public Runtime.
 
 1. Definitions
 
-“Flyfish” means the copyright owner and licensor of the Public Package.
+“Flyfish” means the copyright owner and licensor.
 
-“Public Package” means the official, unmodified @file-viewer/ppt binary npm
-package distributed by Flyfish under this License, including its JavaScript
-loader, native WebAssembly rendering module, declarations, documentation, and
-required Flyfish Viewer watermark.
+“Public Runtime” means the official, unmodified @file-viewer/ppt public npm
+package and its required JavaScript, Worker, WebAssembly, font, declaration,
+manifest, documentation, notice, and Flyfish Viewer watermark files.
 
-“You” means an individual natural person acting solely in that person’s
-personal capacity. A company, legal entity, government body, school, nonprofit,
-team, employer, client, or other organization is not “You” under the free grant,
-even when an individual accesses the Public Package on its behalf.
+“You” means any individual or organization using or distributing the Public
+Runtime under this License.
 
-“Personal Non-Commercial Use” means learning, private research, private testing,
-personal evaluation, or a personal non-revenue project that is not performed
-for, on behalf of, or in connection with any organization, employment, client,
-profession, trade, business, compensation, fee, fundraising, or commercial
-advantage.
+“Integrated Product” means an application, website, service, library, demo,
+deployment bundle, or other product in which the Public Runtime is included as
+a functional dependency for PowerPoint preview rather than offered as a
+standalone substitute for @file-viewer/ppt.
 
-“Commercial Use” means every use that is not Personal Non-Commercial Use.
+2. Public watermarked grant
 
-2. Limited free grant
+Subject to this License, Flyfish grants You a worldwide, royalty-free,
+non-exclusive, non-transferable license to:
 
-Subject to continuous compliance with this License, Flyfish grants You a
-limited, non-exclusive, non-transferable, non-sublicensable, revocable right to:
+- download, install, copy, and execute the Public Runtime for any lawful
+  personal, organizational, educational, government, nonprofit, internal,
+  commercial, production, SaaS, hosted, customer-facing, or professional use;
+- integrate and deploy the Public Runtime in an Integrated Product;
+- bundle or copy the unmodified Public Runtime through npm, package managers,
+  build tools, private registries, static asset directories, Docker images,
+  offline installers, demos, Full packages, CDN/IIFE distributions,
+  copy-assets workflows, and GitHub Release artifacts;
+- host, mirror, and redistribute the unmodified Public Runtime when reasonably
+  required to install, operate, deploy, or distribute an Integrated Product;
+  and
+- charge for an Integrated Product or service that includes the Public Runtime.
 
-- download and install the official Public Package;
-- execute it on any normal HTTP or HTTPS browser origin solely for Personal
-  Non-Commercial Use; and
-- serve unmodified Public Package assets only as an integrated component of
-  Your own Personal Non-Commercial Use project.
+No paid license is required for these uses while the required Flyfish Viewer
+watermark remains visible, complete, unobstructed, and unmodified in every
+rendered slide and preview.
 
-The grant is conditioned on the Flyfish Viewer watermark remaining visible,
-complete, unobstructed, and unmodified in every rendered slide and preview.
-The grant does not include source code, source-delivery rights, redistribution
-rights, modification rights, derivative-work rights, or any commercial right.
+Routine technical bundling, tree-shaking, compression, content hashing, and
+minification are permitted when they do not change runtime behavior, bypass
+integrity checks, remove notices, or alter the required watermark.
 
-3. Commercial and organizational use
+3. Watermark-free commercial authorization
 
-You must obtain a separate written commercial license from Flyfish before any
-Commercial Use. Commercial Use includes, without limitation:
+A separate written commercial authorization is required only to remove,
+replace, hide, crop, cover, weaken, restyle, or otherwise alter the required
+Flyfish Viewer watermark, or to receive a separately built watermark-free
+runtime or source delivery. Commercial authorization applies only to the
+entities, deployments, features, origins, term, and other scope stated in that
+agreement.
 
-- any use by or for a company, organization, government body, school,
-  nonprofit, team, employer, customer, or client, including internal evaluation;
-- production, intranet, extranet, SaaS, hosted, cloud, embedded, OEM, resale,
-  consulting, customer-delivery, revenue-generating, fee-supported, sponsored,
-  or professionally connected use;
-- integration into any product, service, project, procurement, sales demo, or
-  workflow connected with business or compensated activity; and
-- any removal, hiding, obstruction, weakening, alteration, or replacement of
-  the required Flyfish Viewer watermark or public-edition restrictions.
-
-A separately purchased commercial or enterprise agreement applies only to the
-features, deployments, origins, entities, term, and other scope expressly stated
-in that agreement. A commercial agreement does not amend this Public Package.
-Flyfish may instead provide a separately built commercial package.
-
-Purchase and authorization information:
-https://dev.flyfish.group/shop
+Authorization information: https://dev.flyfish.group/shop
 
 4. Restrictions
 
-Except to the limited extent that mandatory law expressly permits despite this
-restriction, You may not, and may not enable or assist another person to:
-
-- redistribute, publish, mirror, sublicense, sell, rent, lease, transfer,
-  repackage, or make the Public Package available as a standalone download,
-  reusable dependency, CDN asset, hosted API, or service for third parties;
-- modify, translate, adapt, patch, or create derivative works from the Public
-  Package, WebAssembly module, or watermark;
+Except to the limited extent mandatory law permits despite these restrictions,
+You may not, and may not enable another person to:
+
+- sell, rent, sublicense, rebrand, rename, or publish the Public Runtime as a
+  standalone or competing package, download, API, hosted conversion service,
+  or product that substitutes for the official @file-viewer/ppt package;
+- represent the Public Runtime as Your own engine, as open source, or as
+  licensed under Apache-2.0, MIT, BSD, GPL, or another open-source license;
+- modify, translate, patch, adapt, or create derivative works from the Public
+  Runtime except for the routine integration transformations expressly allowed
+  in Section 2;
 - reverse engineer, decrypt, decompile, disassemble, extract, dump, recover, or
-  otherwise attempt to derive source code, keys, protected modules, algorithms,
-  or non-public interfaces;
-- bypass, forge, replace, disable, or interfere with any policy gate, integrity
-  check, encryption, feature restriction, watermark control, or other technical
-  protection measure;
+  attempt to derive source code, keys, protected modules, algorithms, or
+  non-public interfaces;
+- bypass, forge, replace, disable, or interfere with a policy gate, integrity
+  check, encryption measure, feature restriction, watermark control, or other
+  technical protection;
 - remove, hide, crop, cover, restyle, obscure, weaken, or interfere with the
-  Flyfish Viewer watermark in the viewer output;
+  required Flyfish Viewer watermark without separate written authorization; or
 - remove or alter copyright, license, attribution, provenance, trademark, or
-  commercial-use notices; or
-- represent the Public Package as open source or as licensed under Apache-2.0,
-  MIT, BSD, GPL, or another open-source license.
-
-Installing the official package through npm and making reasonable backup copies
-solely for Your permitted use are not prohibited redistribution.
-
-Technical bundling, minification, and static-asset deployment are permitted only
-as necessary to operate Your own project within the Limited Free Grant, provided
-that the Public Package is not exposed or supplied as a reusable library,
-standalone dependency, mirror, download, API, or service, and provided that all
-license notices, integrity controls, and required watermarks remain intact.
-
-5. Separate source deliveries and Apache-2.0 boundary
-
-This License applies only to the Public Package and does not grant rights under
-the Apache License 2.0 or any other open-source license.
-
-Any Apache License 2.0 terms that Flyfish may separately provide to a specific
-source-delivery customer apply only to the source files and scope expressly
-identified in that separate delivery. Those terms are not incorporated into,
-and do not extend to, this Public Package, its public WebAssembly distribution,
-the Flyfish Viewer watermark, or Flyfish trademarks.
-Nothing in this License changes rights already validly granted in a separate
-written delivery or license agreement.
-
-6. Watermark and limited trademark permission
-
-The Flyfish name and Flyfish Viewer watermark are protected marks of Flyfish.
-Solely so You can comply with this License, Flyfish grants You a narrow,
-non-transferable permission to display the unmodified mandatory watermark as
-produced by the Public Package. No other trademark, branding, endorsement, or
-merchandising right is granted.
-
-Only a separately purchased and separately built commercial package may omit
-the public watermark. Possession of a license file, source delivery, package
-copy, or modified runtime does not by itself authorize watermark removal.
-
-7. Ownership and reservation of rights
-
-Flyfish and its licensors retain all title, ownership, copyright, patent,
-trade-secret, trademark, and other intellectual-property rights in the Public
-Package. No right is granted by implication, estoppel, exhaustion, or otherwise.
-All rights not expressly granted are reserved.
-
-Third-party components, if expressly identified in accompanying notices, remain
-subject to their respective licenses solely for those identified components.
-No third-party notice expands the grant for Flyfish proprietary components.
-
-8. Updates and policy changes
-
-Each version of the Public Package is governed by the LICENSE file shipped with
-that version. Flyfish may offer later versions under revised terms. Continuing
-to use an updated version constitutes acceptance of the terms shipped with that
-updated version.
-
-9. Termination
-
-This License terminates automatically and immediately upon breach. On
-termination, You must stop all use and delete every copy under Your possession
-or control. Sections 3 through 7 and 9 through 11 survive termination.
-Termination does not limit any other remedy available to Flyfish.
-
-10. Disclaimer and limitation of liability
-
-THE PUBLIC PACKAGE IS PROVIDED “AS IS” AND “AS AVAILABLE,” WITHOUT WARRANTIES OR
-CONDITIONS OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, AVAILABILITY, OR
-SECURITY. TO THE MAXIMUM EXTENT PERMITTED BY LAW, FLYFISH AND ITS LICENSORS WILL
-NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY,
-PUNITIVE, OR COMMERCIAL DAMAGES, OR FOR LOSS OF DATA, PROFITS, REVENUE, GOODWILL,
-OR BUSINESS INTERRUPTION, ARISING FROM OR RELATED TO THE PUBLIC PACKAGE OR THIS
-LICENSE.
-
-11. General
-
-This License is the complete agreement for the Public Package unless You and
-Flyfish have signed a separate written agreement that expressly governs the
-same use. If a provision is unenforceable, it will be limited to the minimum
-extent necessary and the remaining provisions will continue in effect. A waiver
-must be in writing and applies only to the stated instance. You may not assign
-this License. Headings are for convenience only.
-
-12. Contact
-
-Commercial licensing: https://dev.flyfish.group/shop
-Support email: wybaby168@gmail.com
-
-中文摘要（仅便于阅读；如与英文条款冲突，以英文条款为准）
-
-- 本 npm 公网包是 Flyfish 专有二进制发行版，不是开源软件，也不适用
-  Apache-2.0。单独向特定源码客户交付的 Apache-2.0 条款，仅适用于该次交付中
-  明确列出的源码和范围，不会扩展到本公网 npm 包。
-- 免费授权对象仅为以个人身份行事的自然人，且仅限个人、非商用、非组织用途；
-  公司、组织、政府、学校、非营利机构、团队、雇主或客户的内部评估也属于商用。
-- 公网水印版不限制正常 HTTP/HTTPS origin，但每一页必须完整显示
-  Flyfish Viewer 水印。不得删除、遮挡、裁剪、弱化或替换水印。
-- 不得再分发、镜像、转售、重打包、修改、反编译、解密、提取、伪造授权或绕过
-  WASM、完整性校验、功能限制及其他技术保护措施。
-- 在免费授权范围内，仅为运行本人项目而进行必要的前端打包、压缩和静态资源部署
-  是允许的，但不得将本包作为可复用依赖、镜像、独立下载、API 或服务向第三方
-  提供，并且必须完整保留许可证声明、完整性保护和水印。
-- 商业、生产、内网、SaaS、托管、嵌入、OEM、客户项目、收费或其他业务用途，
-  必须先购买单独商业授权；只有单独构建的商业包可以不显示公网水印。
-- 商业授权购买地址：https://dev.flyfish.group/shop
+  third-party notices.
+
+An exact official package mirror, cache, backup, or static copy used to install
+or deploy an Integrated Product is not prohibited standalone redistribution.
+
+5. Proprietary and open-source boundary
+
+This License applies only to the Public Runtime. It does not grant source code,
+source-delivery, patent, trademark, or open-source rights. Apache-2.0 terms that
+may apply to File Viewer or to a separately identified source delivery do not
+extend to @file-viewer/ppt, its WebAssembly runtime, or Flyfish trademarks.
+
+Third-party components identified in the NOTICE remain subject to their own
+licenses. Those notices do not expand the grant for Flyfish proprietary code.
+
+6. Ownership and trademark
+
+Flyfish and its licensors retain all title and intellectual-property rights in
+the Public Runtime. The narrow permission to display the unmodified Flyfish
+Viewer watermark does not grant any other trademark or endorsement right.
+
+7. Termination
+
+This License terminates automatically if You materially violate it. Your rights
+are reinstated when You cure the violation within 30 days after discovery,
+unless Flyfish has notified You of a repeated or intentional violation.
+
+8. Disclaimer and limitation of liability
+
+THE PUBLIC RUNTIME IS PROVIDED “AS IS”, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND. TO THE MAXIMUM EXTENT PERMITTED BY LAW, FLYFISH IS NOT LIABLE FOR INDIRECT,
+INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR EXEMPLARY DAMAGES ARISING FROM ITS USE.
+
+9. Entire license
+
+This License is the complete public grant for the Public Runtime. A separate
+written agreement controls only where it expressly grants additional rights.

package/NOTICE

@@ -1,29 +1,28 @@
 @file-viewer/ppt
 Copyright 2026 Flyfish.
 
-PROPRIETARY PUBLIC BINARY DISTRIBUTION — NOT OPEN SOURCE
+PROPRIETARY PUBLIC WATERMARKED RUNTIME — NOT OPEN SOURCE
 
-This npm package is governed only by the included Flyfish Public Watermarked
-Binary License. It is not licensed under Apache-2.0. Apache-2.0 terms supplied
-under a separate written source-code delivery apply only to the files and scope
-expressly identified in that separate delivery and do not extend to this npm
-package.
+This npm package is governed by the included Flyfish Public Watermarked Runtime
+License. It is not licensed under Apache-2.0. Apache-2.0 terms that may apply to
+File Viewer or a separately identified source delivery do not extend to this
+runtime.
 
-Free use is limited to an individual natural person acting solely in a personal,
-non-commercial, non-organizational capacity. Use by or for any company,
-organization, government body, school, nonprofit, team, employer, customer, or
-client requires a purchased commercial license.
+The unmodified public runtime may be used by individuals and organizations for
+personal, internal, commercial, production, SaaS, hosted, and customer-facing
+applications. It may be bundled, copied, hosted, mirrored, and redistributed as
+an integrated dependency of File Viewer or another application, including npm,
+Full, CDN/IIFE, Docker, offline, copy-assets, and GitHub Release distributions.
 
 Every public rendering must display the unmodified Flyfish Viewer watermark.
-Only a separately purchased and separately built commercial package may omit
-that watermark.
+Only separate written commercial authorization may permit removing, replacing,
+hiding, or weakening that watermark or using a watermark-free build.
 
-This package contains a native PPT parsing and Canvas rasterization WebAssembly
-runtime plus generated public declarations. It does not include a customer
-runtime license, license-signing secret, commercial watermark-removal
-capability, source-delivery rights, or readable parser/renderer source.
+The package contains a native PPT parsing and Canvas rasterization WebAssembly
+runtime plus generated public declarations. It does not include source-delivery
+rights, watermark-removal capability, or readable parser/renderer source.
 
-Commercial licensing: https://dev.flyfish.group/shop
+Commercial watermark authorization: https://dev.flyfish.group/shop
 
 The package ships deterministic fallback font resources separately from the
 native engine. Their copyright notices and full font licenses are appended to
@@ -63,7 +62,6 @@ requirement for fonts to remain under this license does not apply to
 any document created using the fonts or their derivatives.
 
 
-
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such.
@@ -119,12 +117,10 @@ Software, subject to the following conditions:
    Software.
 
 
-
 TERMINATION
 This license becomes null and void if any of the above conditions are not met.
 
 
-
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF

package/README.md

@@ -193,9 +193,9 @@ moves assets, configure them explicitly:
 
 ```js
 const viewer = await createPptViewer({
-  workerUrl: new URL('/vendor/file-viewer/ppt/0.3.0/worker.mjs', location.origin),
-  wasmUrl: new URL('/vendor/file-viewer/ppt/0.3.0/ppt-native.wasm', location.origin),
-  fontUrl: new URL('/vendor/file-viewer/ppt/0.3.0/ppt-font-cjk.otf', location.origin)
+  workerUrl: new URL('/vendor/file-viewer/ppt/0.3.2/worker.mjs', location.origin),
+  wasmUrl: new URL('/vendor/file-viewer/ppt/0.3.2/ppt-native.wasm', location.origin),
+  fontUrl: new URL('/vendor/file-viewer/ppt/0.3.2/ppt-font-cjk.otf', location.origin)
 });
 ```
 
@@ -268,18 +268,20 @@ be used when a document font is not available to the viewer.
 
 | Edition | Permitted use | Watermark | Origin |
 | --- | --- | --- | --- |
-| Public npm edition | Individual personal, non-commercial, non-organizational use | Mandatory `Flyfish Viewer` on every slide | Any normal HTTP/HTTPS origin |
-| Commercial edition | Licensed company, organization, customer project, intranet, SaaS, OEM, or production use | Watermark-free build available according to the purchased agreement | According to the commercial agreement |
+| Public npm edition | Any lawful personal, organizational, commercial, production, SaaS, hosted, or customer-facing use | Mandatory `Flyfish Viewer` on every slide | Any normal HTTP/HTTPS origin |
+| Watermark-free edition | Uses covered by a separate written authorization | Watermark-free build according to the purchased agreement | According to the commercial agreement |
 
-**Commercial use requires a purchased license.** Use by or for a company,
-organization, government body, school, nonprofit, team, employer, customer, or
-client—including internal evaluation—is commercial use.
+The unmodified public runtime can be bundled, self-hosted, and redistributed as
+an integrated dependency, including File Viewer Full, CDN/IIFE, Docker, offline,
+copy-assets, and GitHub Release distributions. A paid authorization is required
+only to remove, replace, hide, or weaken the required watermark, or to receive a
+separate watermark-free build or source delivery.
 
 The public npm edition is proprietary software and is **not licensed under
 Apache-2.0**. Removing, hiding, covering, replacing, or bypassing the required
 watermark is prohibited. See [LICENSE](./LICENSE) for the binding terms.
 
-Purchase a commercial license from the
+Purchase watermark-free commercial authorization from the
 [Flyfish Shop](https://dev.flyfish.group/shop).
 
 ### Product links
@@ -445,7 +447,7 @@ manifest.json
 `application/wasm`，`.otf` 使用 `font/otf`，`.ppt` 使用
 `application/vnd.ms-powerpoint`。
 
-将资源发布在版本化或内容寻址目录（如 `/vendor/file-viewer/ppt/0.3.0/`）后，
+将资源发布在版本化或内容寻址目录（如 `/vendor/file-viewer/ppt/0.3.2/`）后，
 可配置：
 
 ```http
@@ -477,19 +479,20 @@ Cache-Control: public, max-age=31536000, immutable
 
 | 版本 | 允许用途 | 水印 | Origin |
 | --- | --- | --- | --- |
-| 公网 npm 版 | 自然人个人、非商业、非组织用途 | 每页强制显示 `Flyfish Viewer` | 任意正常 HTTP/HTTPS origin |
-| 商业版 | 已授权的公司、组织、客户项目、内网、SaaS、OEM 或生产用途 | 按商业协议提供无公网水印构建 | 按商业协议执行 |
+| 公网 npm 版 | 任何合法的个人、组织、商业、生产、SaaS、内网或客户项目用途 | 每页强制显示 `Flyfish Viewer` | 任意正常 HTTP/HTTPS origin |
+| 无水印版 | 书面商业授权覆盖的用途 | 按协议提供无水印构建 | 按商业协议执行 |
 
-**任何商业用途均需购买授权。** 公司、组织、政府、学校、非营利机构、团队、
-雇主、客户或委托项目的使用，包括内部评估，均属于商业用途。
+未修改的公网运行时可以作为应用依赖打包、自托管和再分发，包括 File Viewer Full、
+CDN/IIFE、Docker、离线包、copy-assets 和 GitHub Release。只有移除、替换、隐藏或
+弱化强制水印，或取得单独的无水印构建/源码交付时，才需要书面商业授权。
 
 公网 npm 版是专有软件，**不适用 Apache-2.0**。禁止删除、隐藏、遮挡、替换或
 绕过强制水印。具有法律约束力的完整条款见 [LICENSE](./LICENSE)。
 
-商业授权请前往 [Flyfish 商店](https://dev.flyfish.group/shop)购买。
+无水印商业授权请前往 [Flyfish 商店](https://dev.flyfish.group/shop)购买。
 
 ### 产品链接
 
 - [产品文档](https://officejs-doc.pages.dev)
-- [商业授权](https://dev.flyfish.group/shop)
+- [无水印商业授权](https://dev.flyfish.group/shop)
 - [问题反馈](https://github.com/flyfish-dev/office-preview-js/issues)

package/index.d.ts

@@ -16,18 +16,21 @@ export interface PptPackageManifest {
   readonly id: 'FV-PPT-PUBLIC-WATERMARKED-V2';
   readonly feature: 'ppt';
   readonly edition: 'public-watermarked';
-  readonly holder: 'Individual Personal Non-Commercial Use';
+  readonly holder: 'Individuals and Organizations';
   readonly distribution: 'proprietary-public-binary';
-  readonly commercialUse: false;
+  readonly commercialUse: true;
   readonly publicAnyOrigin: true;
   readonly watermarkRequired: true;
   readonly watermarkText: 'Flyfish Viewer';
-  readonly usePolicy: 'public-individual-noncommercial-watermarked';
-  readonly licensePolicy: 'flyfish-public-watermarked-binary-license-v1';
+  readonly usePolicy: 'public-watermarked-general-use';
+  readonly licensePolicy: 'flyfish-public-watermarked-binary-license-v2';
   readonly sourceCodeRights: false;
   readonly sourceDeliveryRights: false;
   readonly apacheLicenseApplies: false;
-  readonly redistributionAllowed: false;
+  readonly redistributionAllowed: true;
+  readonly redistributionPolicy: 'unmodified-integrated-bundling-only';
+  readonly standaloneRedistributionAllowed: false;
+  readonly watermarkRemovalRequiresCommercialAuthorization: true;
   readonly runtimeLicenseRequired: false;
   readonly renderer: 'native-wasm-worker-offscreen-canvas';
   readonly integrity: 'native-wasm-font-sha256-v2';
@@ -45,13 +48,16 @@ export interface PptPackageManifest {
 export interface PptRuntimeLicenseSummary {
   readonly id: 'FV-PPT-PUBLIC-WATERMARKED-V2';
   readonly edition: 'public-watermarked';
-  readonly holder: 'Individual Personal Non-Commercial Use';
-  readonly policy: 'flyfish-public-watermarked-binary-license-v1';
-  readonly commercialUse: false;
+  readonly holder: 'Individuals and Organizations';
+  readonly policy: 'flyfish-public-watermarked-binary-license-v2';
+  readonly commercialUse: true;
   readonly sourceCodeRights: false;
   readonly sourceDeliveryRights: false;
   readonly apacheLicenseApplies: false;
-  readonly redistributionAllowed: false;
+  readonly redistributionAllowed: true;
+  readonly redistributionPolicy: 'unmodified-integrated-bundling-only';
+  readonly standaloneRedistributionAllowed: false;
+  readonly watermarkRemovalRequiresCommercialAuthorization: true;
 }
 
 export interface PptWatermarkSummary {

package/index.mjs

@@ -1,4 +1,4 @@
-const MANIFEST = Object.freeze({"kind":"flyfish-ppt-public-native-wasm-v2","product":"Flyfish PPT Viewer","format":"PowerPoint 97-2003 (.ppt)","packageName":"@file-viewer/ppt","packageVersion":"0.3.0","engine":"flyfish-classic-ppt-native-engine","engineBuild":"28e655e6a05c9b73","id":"FV-PPT-PUBLIC-WATERMARKED-V2","feature":"ppt","edition":"public-watermarked","holder":"Individual Personal Non-Commercial Use","distribution":"proprietary-public-binary","commercialUse":false,"publicAnyOrigin":true,"watermarkRequired":true,"watermarkText":"Flyfish Viewer","usePolicy":"public-individual-noncommercial-watermarked","licensePolicy":"flyfish-public-watermarked-binary-license-v1","sourceCodeRights":false,"sourceDeliveryRights":false,"apacheLicenseApplies":false,"redistributionAllowed":false,"runtimeLicenseRequired":false,"renderer":"native-wasm-worker-offscreen-canvas","integrity":"native-wasm-font-sha256-v2","wasmFile":"ppt-native.wasm","wasmBytes":1557607,"workerFile":"worker.mjs","fontPack":{"kind":"flyfish-cjk-font-pack-v1","file":"ppt-font-cjk.otf","bytes":16437364,"sha256":"2c76254f6fc379fddfce0a7e84fb5385bb135d3e399294f6eeb6680d0365b74b"},"workerDefault":true,"virtualScrollDefault":true,"frameCache":"indexeddb-final-watermarked-png-lru","watermarkEnforcement":"native-final-frame","wasmSha256":"c14dd1d5b971817b2eb133739fe928920b9ccc0a5afb25f7044d879bed7c6d23"});
+const MANIFEST = Object.freeze({"kind":"flyfish-ppt-public-native-wasm-v2","product":"Flyfish PPT Viewer","format":"PowerPoint 97-2003 (.ppt)","packageName":"@file-viewer/ppt","packageVersion":"0.3.2","engine":"flyfish-classic-ppt-native-engine","engineBuild":"ee7c677fc3007f1b","id":"FV-PPT-PUBLIC-WATERMARKED-V2","feature":"ppt","edition":"public-watermarked","holder":"Individuals and Organizations","distribution":"proprietary-public-binary","commercialUse":true,"publicAnyOrigin":true,"watermarkRequired":true,"watermarkText":"Flyfish Viewer","usePolicy":"public-watermarked-general-use","licensePolicy":"flyfish-public-watermarked-binary-license-v2","sourceCodeRights":false,"sourceDeliveryRights":false,"apacheLicenseApplies":false,"redistributionAllowed":true,"redistributionPolicy":"unmodified-integrated-bundling-only","standaloneRedistributionAllowed":false,"watermarkRemovalRequiresCommercialAuthorization":true,"runtimeLicenseRequired":false,"renderer":"native-wasm-worker-offscreen-canvas","integrity":"native-wasm-font-sha256-v2","wasmFile":"ppt-native.wasm","wasmBytes":1557871,"workerFile":"worker.mjs","fontPack":{"kind":"flyfish-cjk-font-pack-v1","file":"ppt-font-cjk.otf","bytes":16437364,"sha256":"2c76254f6fc379fddfce0a7e84fb5385bb135d3e399294f6eeb6680d0365b74b"},"workerDefault":true,"virtualScrollDefault":true,"frameCache":"indexeddb-final-watermarked-png-lru","watermarkEnforcement":"native-final-frame","wasmSha256":"6d209f487ab8be74f23b463eaecafd9f588948e75670f82e69d7b7d6b10cb6a7"});
 const DEFAULT_WASM_URL = new URL('./ppt-native.wasm', import.meta.url);
 const DEFAULT_FONT_URL = new URL(`./${MANIFEST.fontPack.file}`, import.meta.url);
 const DEFAULT_WORKER_URL = new URL(`./${MANIFEST.workerFile}`, import.meta.url);
@@ -26,13 +26,16 @@ const WASM_EXPORTS = Object.freeze([
 const LICENSE = Object.freeze({
   id: 'FV-PPT-PUBLIC-WATERMARKED-V2',
   edition: 'public-watermarked',
-  holder: 'Individual Personal Non-Commercial Use',
-  policy: 'flyfish-public-watermarked-binary-license-v1',
-  commercialUse: false,
+  holder: 'Individuals and Organizations',
+  policy: 'flyfish-public-watermarked-binary-license-v2',
+  commercialUse: true,
   sourceCodeRights: false,
   sourceDeliveryRights: false,
   apacheLicenseApplies: false,
-  redistributionAllowed: false
+  redistributionAllowed: true,
+  redistributionPolicy: 'unmodified-integrated-bundling-only',
+  standaloneRedistributionAllowed: false,
+  watermarkRemovalRequiresCommercialAuthorization: true
 });
 
 const WATERMARK = Object.freeze({ required: true, text: 'Flyfish Viewer' });

package/manifest.json

@@ -3,29 +3,32 @@
   "product": "Flyfish PPT Viewer",
   "format": "PowerPoint 97-2003 (.ppt)",
   "packageName": "@file-viewer/ppt",
-  "packageVersion": "0.3.0",
+  "packageVersion": "0.3.2",
   "engine": "flyfish-classic-ppt-native-engine",
-  "engineBuild": "28e655e6a05c9b73",
+  "engineBuild": "ee7c677fc3007f1b",
   "id": "FV-PPT-PUBLIC-WATERMARKED-V2",
   "feature": "ppt",
   "edition": "public-watermarked",
-  "holder": "Individual Personal Non-Commercial Use",
+  "holder": "Individuals and Organizations",
   "distribution": "proprietary-public-binary",
-  "commercialUse": false,
+  "commercialUse": true,
   "publicAnyOrigin": true,
   "watermarkRequired": true,
   "watermarkText": "Flyfish Viewer",
-  "usePolicy": "public-individual-noncommercial-watermarked",
-  "licensePolicy": "flyfish-public-watermarked-binary-license-v1",
+  "usePolicy": "public-watermarked-general-use",
+  "licensePolicy": "flyfish-public-watermarked-binary-license-v2",
   "sourceCodeRights": false,
   "sourceDeliveryRights": false,
   "apacheLicenseApplies": false,
-  "redistributionAllowed": false,
+  "redistributionAllowed": true,
+  "redistributionPolicy": "unmodified-integrated-bundling-only",
+  "standaloneRedistributionAllowed": false,
+  "watermarkRemovalRequiresCommercialAuthorization": true,
   "runtimeLicenseRequired": false,
   "renderer": "native-wasm-worker-offscreen-canvas",
   "integrity": "native-wasm-font-sha256-v2",
   "wasmFile": "ppt-native.wasm",
-  "wasmBytes": 1557607,
+  "wasmBytes": 1557871,
   "workerFile": "worker.mjs",
   "fontPack": {
     "kind": "flyfish-cjk-font-pack-v1",
@@ -37,5 +40,5 @@
   "virtualScrollDefault": true,
   "frameCache": "indexeddb-final-watermarked-png-lru",
   "watermarkEnforcement": "native-final-frame",
-  "wasmSha256": "c14dd1d5b971817b2eb133739fe928920b9ccc0a5afb25f7044d879bed7c6d23"
+  "wasmSha256": "6d209f487ab8be74f23b463eaecafd9f588948e75670f82e69d7b7d6b10cb6a7"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/ppt",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Professional native WebAssembly canvas viewer for PowerPoint 97-2003 (.ppt) files.",
   "type": "module",
   "main": "./index.mjs",

package/worker.mjs

@@ -1,4 +1,734 @@
-import { createFrameCache } from './frame-cache.mjs';
+/**
+ * Bounded, best-effort cache for final watermarked PNG frames.
+ *
+ * This module is intentionally storage-only. It does not parse PPT data, inspect
+ * font assets, or transform renderer output. Every storage failure degrades to a
+ * cache miss so IndexedDB can never become a rendering dependency.
+ */
+
+const DB_VERSION = 1;
+const FRAME_STORE = "frames";
+const META_STORE = "meta";
+const DOCUMENT_INDEX = "byDocument";
+const ACCESS_INDEX = "byLastAccess";
+const USAGE_KEY = "usage";
+
+const MIB = 1024 * 1024;
+const DEFAULT_DB_NAME = "flyfish-ppt-frame-cache-v1";
+const DEFAULT_MAX_BYTES = 256 * MIB;
+const DEFAULT_MAX_ENTRIES = 256;
+const DEFAULT_MAX_ITEM_BYTES = 32 * MIB;
+const MAX_DATABASE_NAME_LENGTH = 128;
+const MAX_DOCUMENT_ID_LENGTH = 256;
+const MAX_VARIANT_LENGTH = 256;
+const MAX_PAGE_INDEX = 10_000_000;
+const MAX_DIMENSION = 65_535;
+const OPEN_TIMEOUT_MS = 1_000;
+
+function clampInteger(value, fallback, minimum, maximum) {
+  let numeric;
+  try {
+    numeric = Number(value);
+  } catch {
+    return fallback;
+  }
+  if (!Number.isFinite(numeric)) {
+    return fallback;
+  }
+  return Math.min(maximum, Math.max(minimum, Math.trunc(numeric)));
+}
+
+function normalizeBoundedString(value, maximumLength, { trim = false } = {}) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = trim ? value.trim() : value;
+  if (normalized.length === 0 || normalized.length > maximumLength) {
+    return null;
+  }
+  return normalized;
+}
+
+/**
+ * Pure limit normalization used by both production code and unit tests.
+ */
+function normalizeFrameCacheLimits(options = {}) {
+  const source = options && typeof options === "object" ? options : {};
+  const maxBytes = clampInteger(source.maxBytes, DEFAULT_MAX_BYTES, 0, 2 * 1024 * MIB);
+  const maxEntries = clampInteger(source.maxEntries, DEFAULT_MAX_ENTRIES, 0, 4_096);
+  const defaultItemBytes = Math.min(DEFAULT_MAX_ITEM_BYTES, maxBytes);
+  const configuredItemBytes = source.maxItemBytes ?? source.maxEntryBytes;
+  const maxItemBytes = maxBytes === 0
+    ? 0
+    : clampInteger(configuredItemBytes, defaultItemBytes, 0, maxBytes);
+  return Object.freeze({ maxBytes, maxEntries, maxItemBytes });
+}
+
+/**
+ * Pure cache-key normalization. Invalid or potentially collision-prone inputs
+ * return null instead of being truncated.
+ */
+function normalizeFrameCacheKey(input, pageIndex, variant = "") {
+  const source = input && typeof input === "object"
+    ? input
+    : { documentId: input, pageIndex, variant };
+
+  const documentId = normalizeBoundedString(source.documentId, MAX_DOCUMENT_ID_LENGTH, { trim: true });
+  let normalizedPageIndex;
+  let normalizedVariant;
+  try {
+    normalizedPageIndex = Number(source.pageIndex);
+    normalizedVariant = source.variant == null ? "" : String(source.variant);
+  } catch {
+    return null;
+  }
+
+  if (
+    documentId == null
+    || !Number.isSafeInteger(normalizedPageIndex)
+    || normalizedPageIndex < 0
+    || normalizedPageIndex > MAX_PAGE_INDEX
+    || normalizedVariant.length > MAX_VARIANT_LENGTH
+  ) {
+    return null;
+  }
+
+  // Length-prefixing prevents separators inside opaque identifiers from
+  // creating collisions.
+  const key = `v1:${documentId.length}:${documentId}:${normalizedPageIndex}:${normalizedVariant.length}:${normalizedVariant}`;
+  return Object.freeze({
+    key,
+    documentId,
+    pageIndex: normalizedPageIndex,
+    variant: normalizedVariant,
+  });
+}
+
+function createFrameCacheKey(documentId, pageIndex, variant = "") {
+  return normalizeFrameCacheKey(documentId, pageIndex, variant)?.key ?? null;
+}
+
+function normalizeDatabaseName(value) {
+  return normalizeBoundedString(value, MAX_DATABASE_NAME_LENGTH, { trim: true }) ?? DEFAULT_DB_NAME;
+}
+
+function isPngBlob(blob) {
+  return Boolean(
+    blob
+    && typeof blob === "object"
+    && Number.isSafeInteger(blob.size)
+    && blob.size > 0
+    && typeof blob.arrayBuffer === "function"
+    && typeof blob.type === "string"
+    && blob.type.toLowerCase() === "image/png",
+  );
+}
+
+function normalizeDimension(value) {
+  let numeric;
+  try {
+    numeric = Number(value);
+  } catch {
+    return null;
+  }
+  return Number.isSafeInteger(numeric) && numeric > 0 && numeric <= MAX_DIMENSION
+    ? numeric
+    : null;
+}
+
+function normalizePutArguments(keyInput, frameInput, limits) {
+  const frame = frameInput && typeof frameInput === "object" ? frameInput : keyInput;
+  const key = normalizeFrameCacheKey(keyInput);
+  const width = normalizeDimension(frame?.width);
+  const height = normalizeDimension(frame?.height);
+  const blob = frame?.blob;
+
+  if (key == null || width == null || height == null || !isPngBlob(blob)) {
+    return null;
+  }
+  if (blob.size > limits.maxItemBytes || blob.size > limits.maxBytes) {
+    return null;
+  }
+  return { ...key, blob, width, height, byteSize: blob.size };
+}
+
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+
+function transactionError(transaction, fallbackMessage) {
+  return transaction.error ?? new Error(fallbackMessage);
+}
+
+function openDatabase(factory, dbName) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let request;
+    let timer = null;
+
+    const settle = (callback, value) => {
+      if (settled) {
+        if (value && typeof value.close === "function") {
+          value.close();
+        }
+        return;
+      }
+      settled = true;
+      if (timer != null) {
+        clearTimeout(timer);
+      }
+      callback(value);
+    };
+
+    try {
+      request = factory.open(dbName, DB_VERSION);
+    } catch (error) {
+      settle(reject, error);
+      return;
+    }
+
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      let frameStore;
+      if (!database.objectStoreNames.contains(FRAME_STORE)) {
+        frameStore = database.createObjectStore(FRAME_STORE, { keyPath: "key" });
+      } else {
+        frameStore = request.transaction.objectStore(FRAME_STORE);
+      }
+      if (!frameStore.indexNames.contains(DOCUMENT_INDEX)) {
+        frameStore.createIndex(DOCUMENT_INDEX, "documentId", { unique: false });
+      }
+      if (!frameStore.indexNames.contains(ACCESS_INDEX)) {
+        frameStore.createIndex(ACCESS_INDEX, "lastAccess", { unique: false });
+      }
+      if (!database.objectStoreNames.contains(META_STORE)) {
+        database.createObjectStore(META_STORE, { keyPath: "key" });
+      }
+    };
+    request.onsuccess = () => settle(resolve, request.result);
+    request.onerror = () => settle(reject, request.error ?? new Error("Unable to open IndexedDB"));
+    request.onblocked = () => settle(reject, new Error("IndexedDB open was blocked"));
+
+    if (typeof setTimeout === "function") {
+      timer = setTimeout(() => {
+        settle(reject, new Error("IndexedDB open timed out"));
+      }, OPEN_TIMEOUT_MS);
+    }
+  });
+}
+
+function isStoredFrameValid(record) {
+  return Boolean(
+    record
+    && typeof record === "object"
+    && typeof record.key === "string"
+    && typeof record.documentId === "string"
+    && Number.isSafeInteger(record.pageIndex)
+    && normalizeDimension(record.width) != null
+    && normalizeDimension(record.height) != null
+    && Number.isSafeInteger(record.byteSize)
+    && record.byteSize > 0
+    && isPngBlob(record.blob)
+    && record.blob.size === record.byteSize,
+  );
+}
+
+function reconcileUsage(database, limits) {
+  return new Promise((resolve, reject) => {
+    let transaction;
+    try {
+      transaction = database.transaction([FRAME_STORE, META_STORE], "readwrite");
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const frames = transaction.objectStore(FRAME_STORE);
+    const meta = transaction.objectStore(META_STORE);
+    let totalBytes = 0;
+    let totalEntries = 0;
+
+    const writeUsage = () => {
+      meta.put({
+        key: USAGE_KEY,
+        totalBytes,
+        totalEntries,
+        updatedAt: Date.now(),
+      });
+    };
+
+    const withinLimits = () => (
+      totalBytes <= limits.maxBytes
+      && totalEntries <= limits.maxEntries
+    );
+
+    const trimOldest = () => {
+      if (withinLimits()) {
+        writeUsage();
+        return;
+      }
+      const trimRequest = frames.index(ACCESS_INDEX).openCursor();
+      trimRequest.onsuccess = () => {
+        const cursor = trimRequest.result;
+        if (cursor == null) {
+          totalBytes = 0;
+          totalEntries = 0;
+          writeUsage();
+          return;
+        }
+        const record = cursor.value;
+        cursor.delete();
+        if (isStoredFrameValid(record)) {
+          totalBytes = Math.max(0, totalBytes - record.byteSize);
+          totalEntries = Math.max(0, totalEntries - 1);
+        }
+        if (withinLimits()) {
+          writeUsage();
+        } else {
+          cursor.continue();
+        }
+      };
+    };
+
+    const cursorRequest = frames.openCursor();
+    cursorRequest.onsuccess = () => {
+      const cursor = cursorRequest.result;
+      if (cursor == null) {
+        trimOldest();
+        return;
+      }
+      const record = cursor.value;
+      if (isStoredFrameValid(record) && record.byteSize <= limits.maxItemBytes) {
+        totalBytes += record.byteSize;
+        totalEntries += 1;
+      } else {
+        cursor.delete();
+      }
+      cursor.continue();
+    };
+
+    transaction.oncomplete = () => resolve({ totalBytes, totalEntries });
+    transaction.onerror = () => reject(transactionError(transaction, "IndexedDB reconciliation failed"));
+    transaction.onabort = () => reject(transactionError(transaction, "IndexedDB reconciliation was aborted"));
+  });
+}
+
+function readUsageRecord(value) {
+  const totalBytes = Number.isSafeInteger(value?.totalBytes) && value.totalBytes >= 0
+    ? value.totalBytes
+    : 0;
+  const totalEntries = Number.isSafeInteger(value?.totalEntries) && value.totalEntries >= 0
+    ? value.totalEntries
+    : 0;
+  return { totalBytes, totalEntries };
+}
+
+function putFrame(database, record, limits) {
+  return new Promise((resolve, reject) => {
+    let transaction;
+    try {
+      transaction = database.transaction([FRAME_STORE, META_STORE], "readwrite");
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const frames = transaction.objectStore(FRAME_STORE);
+    const meta = transaction.objectStore(META_STORE);
+    let existing;
+    let usage;
+    let existingReady = false;
+    let usageReady = false;
+    let started = false;
+
+    const failRequest = () => {
+      try {
+        transaction.abort();
+      } catch {
+        // The transaction may already have been aborted by the browser.
+      }
+    };
+
+    const finalizeWrite = () => {
+      const now = record.lastAccess;
+      frames.put(record);
+      meta.put({
+        key: USAGE_KEY,
+        totalBytes: usage.totalBytes,
+        totalEntries: usage.totalEntries,
+        updatedAt: now,
+      });
+    };
+
+    const evictIfNeeded = () => {
+      if (started || !existingReady || !usageReady) {
+        return;
+      }
+      started = true;
+
+      const oldBytes = isStoredFrameValid(existing) ? existing.byteSize : 0;
+      const oldEntries = isStoredFrameValid(existing) ? 1 : 0;
+      usage.totalBytes = Math.max(0, usage.totalBytes - oldBytes) + record.byteSize;
+      usage.totalEntries = Math.max(0, usage.totalEntries - oldEntries) + 1;
+
+      const withinLimits = () => (
+        usage.totalBytes <= limits.maxBytes
+        && usage.totalEntries <= limits.maxEntries
+      );
+
+      if (withinLimits()) {
+        finalizeWrite();
+        return;
+      }
+
+      const cursorRequest = frames.index(ACCESS_INDEX).openCursor();
+      cursorRequest.onsuccess = () => {
+        const cursor = cursorRequest.result;
+        if (cursor == null) {
+          if (withinLimits()) {
+            finalizeWrite();
+          } else {
+            failRequest();
+          }
+          return;
+        }
+
+        const candidate = cursor.value;
+        if (candidate?.key !== record.key && isStoredFrameValid(candidate)) {
+          cursor.delete();
+          usage.totalBytes = Math.max(0, usage.totalBytes - candidate.byteSize);
+          usage.totalEntries = Math.max(0, usage.totalEntries - 1);
+        } else if (candidate?.key !== record.key) {
+          cursor.delete();
+        }
+
+        if (withinLimits()) {
+          finalizeWrite();
+        } else {
+          cursor.continue();
+        }
+      };
+      cursorRequest.onerror = failRequest;
+    };
+
+    const existingRequest = frames.get(record.key);
+    existingRequest.onsuccess = () => {
+      existing = existingRequest.result;
+      existingReady = true;
+      evictIfNeeded();
+    };
+    existingRequest.onerror = failRequest;
+
+    const usageRequest = meta.get(USAGE_KEY);
+    usageRequest.onsuccess = () => {
+      usage = readUsageRecord(usageRequest.result);
+      usageReady = true;
+      evictIfNeeded();
+    };
+    usageRequest.onerror = failRequest;
+
+    transaction.oncomplete = () => resolve(true);
+    transaction.onerror = () => reject(transactionError(transaction, "IndexedDB frame write failed"));
+    transaction.onabort = () => reject(transactionError(transaction, "IndexedDB frame write was aborted"));
+  });
+}
+
+function getFrame(database, key, nextAccess) {
+  return new Promise((resolve, reject) => {
+    let transaction;
+    try {
+      transaction = database.transaction(FRAME_STORE, "readwrite");
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const store = transaction.objectStore(FRAME_STORE);
+    let result = null;
+    const request = store.get(key.key);
+    request.onsuccess = () => {
+      const record = request.result;
+      if (!isStoredFrameValid(record)) {
+        if (record != null) {
+          store.delete(key.key);
+        }
+        return;
+      }
+      record.lastAccess = nextAccess();
+      store.put(record);
+      result = {
+        blob: record.blob,
+        width: record.width,
+        height: record.height,
+        byteSize: record.byteSize,
+        lastAccess: record.lastAccess,
+      };
+    };
+
+    transaction.oncomplete = () => resolve(result);
+    transaction.onerror = () => reject(transactionError(transaction, "IndexedDB frame read failed"));
+    transaction.onabort = () => reject(transactionError(transaction, "IndexedDB frame read was aborted"));
+  });
+}
+
+function deleteFrame(database, key) {
+  return new Promise((resolve, reject) => {
+    let transaction;
+    try {
+      transaction = database.transaction([FRAME_STORE, META_STORE], "readwrite");
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const frames = transaction.objectStore(FRAME_STORE);
+    const meta = transaction.objectStore(META_STORE);
+    let deleted = false;
+    const getRequest = frames.get(key.key);
+    getRequest.onsuccess = () => {
+      const existing = getRequest.result;
+      if (existing == null) {
+        return;
+      }
+      deleted = true;
+      const existingIsValid = isStoredFrameValid(existing);
+      const usageRequest = meta.get(USAGE_KEY);
+      usageRequest.onsuccess = () => {
+        const usage = readUsageRecord(usageRequest.result);
+        frames.delete(key.key);
+        meta.put({
+          key: USAGE_KEY,
+          totalBytes: Math.max(0, usage.totalBytes - (existingIsValid ? existing.byteSize : 0)),
+          totalEntries: Math.max(0, usage.totalEntries - (existingIsValid ? 1 : 0)),
+          updatedAt: Date.now(),
+        });
+      };
+    };
+
+    transaction.oncomplete = () => resolve(deleted);
+    transaction.onerror = () => reject(transactionError(transaction, "IndexedDB frame delete failed"));
+    transaction.onabort = () => reject(transactionError(transaction, "IndexedDB frame delete was aborted"));
+  });
+}
+
+function clearDocumentFrames(database, documentId) {
+  return new Promise((resolve, reject) => {
+    let transaction;
+    try {
+      transaction = database.transaction([FRAME_STORE, META_STORE], "readwrite");
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const frames = transaction.objectStore(FRAME_STORE);
+    const meta = transaction.objectStore(META_STORE);
+    let usage = null;
+    let cursorFinished = false;
+    let deletedEntries = 0;
+    let deletedBytes = 0;
+    let finalized = false;
+
+    const maybeFinalize = () => {
+      if (finalized || usage == null || !cursorFinished) {
+        return;
+      }
+      finalized = true;
+      meta.put({
+        key: USAGE_KEY,
+        totalBytes: Math.max(0, usage.totalBytes - deletedBytes),
+        totalEntries: Math.max(0, usage.totalEntries - deletedEntries),
+        updatedAt: Date.now(),
+      });
+    };
+
+    const usageRequest = meta.get(USAGE_KEY);
+    usageRequest.onsuccess = () => {
+      usage = readUsageRecord(usageRequest.result);
+      maybeFinalize();
+    };
+
+    const cursorRequest = frames.index(DOCUMENT_INDEX).openCursor(documentId);
+    cursorRequest.onsuccess = () => {
+      const cursor = cursorRequest.result;
+      if (cursor == null) {
+        cursorFinished = true;
+        maybeFinalize();
+        return;
+      }
+      const record = cursor.value;
+      if (isStoredFrameValid(record)) {
+        deletedEntries += 1;
+        deletedBytes += record.byteSize;
+      }
+      cursor.delete();
+      cursor.continue();
+    };
+
+    transaction.oncomplete = () => resolve(deletedEntries);
+    transaction.onerror = () => reject(transactionError(transaction, "IndexedDB document clear failed"));
+    transaction.onabort = () => reject(transactionError(transaction, "IndexedDB document clear was aborted"));
+  });
+}
+
+/**
+ * Create a cache facade that is safe in Window and DedicatedWorkerGlobalScope.
+ * The facade is synchronous; all storage methods are asynchronous and never
+ * throw for storage availability, quota, cloning, or transaction failures.
+ */
+function createFrameCache(options = {}) {
+  const source = options && typeof options === "object" ? options : {};
+  const limits = normalizeFrameCacheLimits(source);
+  const dbName = normalizeDatabaseName(source.dbName);
+  const factory = source.indexedDB ?? globalThis.indexedDB;
+  const enabled = source.enabled !== false;
+  let closed = false;
+  let disabledReason = !enabled
+    ? "disabled"
+    : factory && typeof factory.open === "function"
+      ? null
+      : "unavailable";
+  let databasePromise = null;
+  let lastAccess = 0;
+
+  const nextAccess = () => {
+    lastAccess = Math.max(Date.now(), lastAccess + 1);
+    return lastAccess;
+  };
+
+  const disable = (error) => {
+    if (disabledReason == null) {
+      disabledReason = typeof error?.name === "string" && error.name
+        ? error.name
+        : "storage-error";
+    }
+    if (databasePromise != null) {
+      databasePromise.then((database) => database?.close()).catch(() => {});
+    }
+  };
+
+  const getDatabase = async () => {
+    if (closed || disabledReason != null) {
+      return null;
+    }
+    if (databasePromise == null) {
+      databasePromise = openDatabase(factory, dbName)
+        .then(async (database) => {
+          database.onversionchange = () => {
+            database.close();
+            disable({ name: "version-change" });
+          };
+          await reconcileUsage(database, limits);
+          return database;
+        })
+        .catch((error) => {
+          disable(error);
+          return null;
+        });
+    }
+    return databasePromise;
+  };
+
+  const run = async (operation, fallback) => {
+    if (closed || disabledReason != null) {
+      return fallback;
+    }
+    const database = await getDatabase();
+    if (database == null) {
+      return fallback;
+    }
+    try {
+      return await operation(database);
+    } catch (error) {
+      // QuotaExceededError, Safari's InvalidStateError / TransactionInactiveError,
+      // private-mode failures, and structured-clone failures all become misses.
+      disable(error);
+      return fallback;
+    }
+  };
+
+  return Object.freeze({
+    async get(keyInput) {
+      const key = normalizeFrameCacheKey(keyInput);
+      if (key == null) {
+        return null;
+      }
+      return run((database) => getFrame(database, key, nextAccess), null);
+    },
+
+    async put(keyInput, frameInput) {
+      const input = normalizePutArguments(keyInput, frameInput, limits);
+      if (input == null) {
+        return false;
+      }
+      const record = {
+        ...input,
+        lastAccess: nextAccess(),
+      };
+      return run((database) => putFrame(database, record, limits), false);
+    },
+
+    async delete(keyInput) {
+      const key = normalizeFrameCacheKey(keyInput);
+      if (key == null) {
+        return false;
+      }
+      return run((database) => deleteFrame(database, key), false);
+    },
+
+    async clearDocument(documentId) {
+      const normalized = normalizeBoundedString(documentId, MAX_DOCUMENT_ID_LENGTH, { trim: true });
+      if (normalized == null) {
+        return 0;
+      }
+      return run((database) => clearDocumentFrames(database, normalized), 0);
+    },
+
+    async stats() {
+      const unavailable = () => ({
+        available: false,
+        disabledReason: closed ? "closed" : disabledReason ?? "unavailable",
+        entries: 0,
+        totalBytes: 0,
+        ...limits,
+      });
+      if (closed || disabledReason != null) {
+        return unavailable();
+      }
+      const result = await run(async (database) => {
+        let transaction;
+        try {
+          transaction = database.transaction(META_STORE, "readonly");
+        } catch (error) {
+          throw error;
+        }
+        const value = await requestResult(transaction.objectStore(META_STORE).get(USAGE_KEY));
+        const usage = readUsageRecord(value);
+        return {
+          available: true,
+          disabledReason: null,
+          entries: usage.totalEntries,
+          totalBytes: usage.totalBytes,
+          ...limits,
+        };
+      }, null);
+      return result ?? unavailable();
+    },
+
+    close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      if (databasePromise != null) {
+        databasePromise.then((database) => database?.close()).catch(() => {});
+      }
+    },
+  });
+}
 
 const WASM_EXPORTS = Object.freeze([
   'memory',