@stapel/cdn-react 0.1.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @stapel/cdn-react

package/MODULE.md

@@ -0,0 +1,124 @@
+# @stapel/cdn-react — module guide
+
+Headless React pair for **stapel-cdn**. This is the human companion to the
+generated `llms.txt` (agent context) and `manifest.json` (machine catalog).
+
+## The one thing to understand first: dedup is a step, not a side effect
+
+Three modules in this fleet upload media, under three DIFFERENT contracts: cdn
+takes a multipart POST, docs opens a session and finalises it, recordings opens
+a session with a size ceiling. They were never one algorithm wearing three hats,
+and this package does not pretend otherwise — it implements **cdn's** contract.
+The two genuinely contract-free bones the other two shared were extracted into
+`@stapel/core` instead (`putToForeignOrigin`, `useObjectUrlPreview`), and only
+the second of them appears here: there is no foreign origin in this contract to
+PUT to.
+
+What cdn's contract has, and the others do not, is a content-addressed store
+with a public "do you already have these bytes?" question. So the flow is:
+
+```
+validate ─┬─ refuse (client-side mirror, cdn's own error codes)
+          │
+          └─ hash ── GET file/exists/?file_hash=… ─┬─ HIT  → done, no POST
+                                                   │
+                                                   └─ MISS → POST multipart
+                                                              └─ poll for variants
+```
+
+`test/dedup.test.ts` asserts the HIT leg by **counting requests**, which is the
+only assertion that cannot be satisfied by a flow that merely looks right.
+
+### What a hit promises, and what a miss does not
+
+A hit means: these bytes are stored, owned by this caller, as the asset type
+this upload would produce. All three conditions are checked, because
+`file/exists/` answers about any object with those bytes — the same file stored
+earlier as a video, or as an avatar rather than a listing photo, is not the row
+the POST would return, and short-circuiting on it would hand a composer a
+reference to the wrong thing.
+
+A miss promises nothing about the server. `file/exists/` filters on
+`uploaded_by=request.user` **unconditionally**, while the upload views honour
+`STAPEL_CDN["DEDUP_SCOPE"]` (default `"owner"`, optionally `"global"`). Under a
+global scope the POST can still answer 200 "already exists". `deduped` therefore
+reports what this client observed, never a claim about what the server did.
+
+## Layers
+
+| Layer | What lives there |
+|---|---|
+| `api/generated/schema.ts` | `pnpm gen:api` from stapel-cdn's `docs/schema.json`. Never hand-edited. |
+| `api/types.ts` | The public projection, with two documented widenings (see below). |
+| `api/cdnApi.ts` | One method per endpoint a browser may call. The one legal home of a path string. |
+| `model/limits.ts` | The client-side mirror of `STAPEL_CDN`'s ceilings — configurable, because they are settings. |
+| `model/hash.ts` | SHA-256 over the file, and the honest answer when the platform cannot compute one. |
+| `model/upload.ts` | The flow. No React. |
+| `model/refs.ts` | `<type>/<hash>` and the single conversion to `@stapel/image`'s ladder. |
+| `model/queries.ts` | `useCdnRef` — the pair's one cached read. |
+| `headless/` | `useUploadQueue` / `useUploadImage` and their render-prop components. |
+| `default/` | The antd skin, behind its own subpath. |
+| `i18n/` | Keys + the generated error bundles + authored ru/es. |
+| `flows/registry.ts` | The zero-flow shim: stapel-cdn annotates no `@flow_step`. |
+
+## Two widenings of the generated types, and why
+
+1. **`Image.type` is a string here, not the generated `"avatar"` enum.** The
+   schema builds `TypeEnum` from `STAPEL_CDN["ASSET_TYPES"]`, whose library
+   default is `("avatar",)`. `POST /upload/image/` never reads that setting: it
+   writes `type="product"` unconditionally. So on a default deployment the
+   general intake returns a value the generated union does not contain — and
+   `POST /images/product/upload/` (which DOES validate against `ASSET_TYPES`)
+   answers 400 for the very type the other endpoint just stored. Both facts are
+   upstream's; the pair reflects them rather than pretending the enum is closed.
+2. **`FileExistsResponse.type`** is `string | null` on the wire. `CdnFileKind`
+   names the three values the view can produce without narrowing the parsed
+   value, so a fourth kind added upstream is not a runtime cast that lies.
+
+## The progress question, answered once
+
+There is no honest byte-percentage available. `fetch` cannot observe
+request-body progress through the injected client, and `SubtleCrypto.digest`
+takes the whole buffer and reports nothing until it is done. The two ways to
+show a moving bar anyway are to fork the transport onto `XMLHttpRequest` — a
+second transport with its own bearer/refresh/verification/error handling, i.e.
+the duplication this package exists to end — or to animate a number nobody
+measured. `UploadPhase` names the step instead, and the skins render an
+indeterminate indicator for the two steps that take real time.
+
+## The gates a composer reads
+
+```ts
+bag.canAdd    // available | blocked{ cdn.upload.blocked.full, {max} }
+bag.settled   // available | blocked{ …blocked.pending } | blocked{ …blocked.failed }
+```
+
+Both are `ActionAvailability` rather than booleans because a Save button that is
+off has to be able to say WHICH of the two reasons it is. `bag.refs` contains
+only settled references, so it is never a promise about bytes that are not
+there.
+
+## Upstream notes (recorded, not worked around)
+
+- **No public read-by-reference.** `file/exists/` is owner-scoped, so nothing in
+  this contract resolves a stranger's `<type>/<hash>` to URLs. A storefront
+  renders a listing's photos from the listings API's own payload.
+- **`refs/sync/` is `IsServiceRequest`** and unreachable from a browser: the
+  consuming module's server syncs references. Not on this pair's API surface.
+- **`GET /images/{type}/random/` is `IsStaffUser`** — an admin convenience, not
+  a storefront operation. Also not on the surface.
+- **413 is undeclared for the image endpoints.** `upload/video/` lists it;
+  `upload/image/`, `upload/avatar/` and `images/{type}/upload/` describe the
+  ceiling in prose and return 413 without declaring it in `responses`. The pair
+  handles it identically for all four.
+- **The variant ladder has no readiness callback.** Polling `file/exists/` is the
+  only way to learn that the background task finished, so the wait is bounded
+  and its exhaustion is a stated outcome (`variantsReady: false`), not a hang.
+
+## Testing
+
+`test/` mocks the WIRE, never the module: every request goes through the real
+`StapelClient`, the bodies are the ones stapel-cdn's serializers render, and the
+SHA-256 is really computed — which is what makes the request-count assertions
+meaningful. jsdom's gaps (`Blob.prototype.arrayBuffer`, `URL.createObjectURL`)
+are filled minimally in `test/vitest.setup.ts` and nowhere else.

package/README.md

@@ -0,0 +1,103 @@
+# @stapel/cdn-react
+
+Headless React pair for **stapel-cdn** (frontend-standard §2). Business + state
+only in the main entry, zero visual opinion — any design layers on top. Built on
+`@stapel/core` (typed client + `StapelApiError` envelope, token refresh,
+verification-403 interception, i18n engine, TanStack Query).
+
+It uploads media the way stapel-cdn wants it uploaded, and its first move is not
+to upload: it hashes the file and asks whether the CDN already has these bytes.
+When it does, nothing is sent.
+
+## Install
+
+```
+pnpm add @stapel/cdn-react @stapel/core @tanstack/react-query react
+```
+
+## Wire the app once
+
+```tsx
+import { CdnProvider, createCdnRuntime } from "@stapel/cdn-react";
+
+const cdn = createCdnRuntime({ baseUrl: "/cdn/api/v1/" });
+
+<StapelConfigProvider config={{ clients: { cdn: cdn.client } }}>
+  <CdnProvider runtime={cdn}>{app}</CdnProvider>
+</StapelConfigProvider>;
+```
+
+## A gallery (what a listing composer uses)
+
+```tsx
+import { MediaUploader } from "@stapel/cdn-react";
+
+<MediaUploader max={10} onRefsChange={(refs) => form.set("images_draft", refs)}>
+  {({ items, refs, canAdd, settled, add, remove, reorder }) => …}
+</MediaUploader>;
+```
+
+`refs` is the list of `<type>/<hash>` strings to store, **in display order**.
+`canAdd` and `settled` are `ActionAvailability`, so the Add button and the Save
+button can each say why they are off — "this gallery holds at most 10 photos",
+"wait for the uploads to finish", "retry the photos that failed".
+
+The antd skin over the same bag is one import away:
+
+```tsx
+import { MediaGalleryField, ImageUploadField } from "@stapel/cdn-react/default";
+```
+
+## One slot (avatar, cover)
+
+```tsx
+const { upload, previewUrl, phase, error } = useUploadImage({
+  target: { kind: "avatar" },
+});
+```
+
+## What the flow does, in order
+
+```
+validate ─┬─ refuse (client-side mirror of the deployment's own ceilings)
+          └─ hash ── file/exists/ ─┬─ HIT  → done, ZERO bytes sent
+                                   └─ MISS → multipart POST → wait for variants
+```
+
+## Three things worth knowing before you use it
+
+**There is no progress percentage, on purpose.** `fetch` cannot observe how much
+of a request body has gone out, and `crypto.subtle.digest` reports nothing
+mid-digest. So the bag names the **phase** — hashing, checking, uploading,
+preparing previews — and a skin shows an indeterminate indicator. Getting a real
+number would mean re-implementing the upload on `XMLHttpRequest`, with its own
+copy of the client's auth, refresh and error handling. A bar that is measured
+beats a bar that moves.
+
+**The pre-check can be skipped and that is never fatal.** `file/exists/` needs
+`IsAuthenticated`, while the upload endpoints take `IsNotAnonymousUser` — so a
+guest can upload but cannot pre-check. A page served over plain `http://` has no
+`crypto.subtle` at all. Both fall through to the POST (the server deduplicates
+on its own side regardless) and report `dedupSkipped` so a skin can explain it.
+
+**Reading somebody else's reference is not possible here, and that is upstream's
+gap, not this pair's.** `file/exists/` filters on `uploaded_by=request.user`
+unconditionally, so `useCdnRef` resolves the caller's OWN references — which is
+what a reopened draft needs and what a buyer looking at a seller's gallery does
+not. stapel-cdn exposes no public read-by-reference endpoint; a storefront
+renders a listing's photos from what the listings API hands it. Recorded here
+rather than worked around with a URL convention this pair would have invented.
+
+## Layers
+
+`api/` (generated schema + the typed operations) → `model/` (the flow, the
+limits mirror, the reference, the one cached read) → `headless/` (the bags and
+their render-prop components) → `i18n/`. `default/` is the antd skin behind its
+own subpath. `MODULE.md` has the full map.
+
+## Locales
+
+English is inline. `./i18n/ru` and `./i18n/es` are opt-in subpaths. stapel-cdn
+ships no `translations/` directory at all, so the 11 error keys it owns are
+authored in this package until upstream localizes them; the 42 cross-cutting
+keys come from stapel-core's catalogue through `gen:errors`.

package/dist/api/cdnApi.d.ts

@@ -0,0 +1,122 @@
+import type { StapelClient } from "@stapel/core";
+import type { CdnFileExistsResponse, CdnFileUploadResponse, CdnImageUploadResponse, CdnVideoUploadResponse } from "./types.js";
+/**
+ * The pair's typed operation surface — one method per stapel-cdn endpoint a
+ * browser may call, bound to the injected {@link StapelClient} (the per-module
+ * override seam of frontend-standard §7.2). Paths are relative to the
+ * runtime's `baseUrl` (`/cdn/api/v1/`).
+ *
+ * ── The two endpoints that are NOT here, and why ───────────────────────────
+ *
+ * `POST /refs/sync/` is `IsServiceRequest`: it is how one BACKEND tells the
+ * CDN that an entity now references a set of media, and a browser cannot
+ * authenticate as a service. A pair that exposed it would invite a screen to
+ * call something that can only answer 403 (`stapel_cdn/views.py`, RefSyncView).
+ * Reference bookkeeping is the consuming module's server-side job — the
+ * storefront's part is to hand `images_draft` to stapel-listings and let it
+ * sync.
+ *
+ * `GET /images/{image_type}/random/` is `IsStaffUser` and exists to let an
+ * admin UI grab a test image. Same argument.
+ *
+ * Both stay in the generated schema (and therefore in `manifest.json`, which
+ * lists the whole contract), so nothing is hidden; they are simply not this
+ * pair's surface.
+ *
+ * ── Upload is a POST of `multipart/form-data`, not a presigned PUT ─────────
+ *
+ * This is the whole reason `@stapel/core`'s `putToForeignOrigin` does not
+ * appear anywhere in this package. That primitive exists for the docs and
+ * recordings contracts, which open a session and hand back a URL at an object
+ * store. stapel-cdn takes the bytes itself, through the same authenticated
+ * origin as every other call, so the injected client IS the right instrument
+ * here and there is no foreign origin to PUT to. Three upload implementations,
+ * three contracts (spec §1.6) — the bones core extracted are the ones the
+ * OTHER two share.
+ */
+export interface CdnApi {
+    readonly client: StapelClient;
+    /**
+     * Has the CDN already got these bytes?
+     *
+     * The dedup pre-check, and the pair's only read. Answers `200` either way:
+     * `{exists: false, type: null, file: null}` is a successful answer, not an
+     * error — "we asked and there is none" (`FileExistsView`).
+     *
+     * OWNER-SCOPED, ALWAYS. The view filters on `uploaded_by=request.user`
+     * unconditionally, unlike the upload paths, which honour
+     * `STAPEL_CDN["DEDUP_SCOPE"]`. Two consequences the flow in `model/upload.ts`
+     * is built around: (a) a miss here does NOT mean the upload will store new
+     * bytes — under `DEDUP_SCOPE: "global"` the POST may still answer "already
+     * exists"; (b) a buyer cannot resolve a seller's reference through this
+     * endpoint, so it is a re-open-your-own-draft read, never a public one.
+     *
+     * `IsAuthenticated | IsServiceRequest` — note that this is STRICTER than the
+     * upload endpoints, which take `IsNotAnonymousUser` (a guest identity is
+     * enough). A guest can therefore upload but not pre-check, which is why a
+     * 401 here is a skipped optimisation rather than a failed upload.
+     */
+    fileExists(fileHash: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<CdnFileExistsResponse>;
+    /**
+     * `POST /upload/image/` — the general image intake (`IsNotAnonymousUser`).
+     *
+     * Answers `201` for stored bytes and `200` for a server-side dedup hit, with
+     * the SAME body either way. The pair does not report which: `StapelClient`
+     * resolves a body, not a status, and the only in-body difference is the
+     * English `message` string, which is not a contract. Dedup is therefore
+     * reported from the pre-check (which is a contract) and from nowhere else —
+     * see `model/upload.ts`.
+     *
+     * The stored row's `type` is `"product"`, hardcoded in the view.
+     */
+    uploadImage(file: File, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<CdnImageUploadResponse>;
+    /**
+     * `POST /upload/avatar/` — the same intake with `type="avatar"`, and the one
+     * upload endpoint that requires a real `IsAuthenticated` principal. This is
+     * what `profiles-react`'s `useSetAvatar` calls (today through its own
+     * documented stopgap, `api/cdnAvatarApi.ts`, which this pair exists to
+     * replace).
+     */
+    uploadAvatar(file: File, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<CdnImageUploadResponse>;
+    /**
+     * `POST /images/{image_type}/upload/` — an image stored under a caller-named
+     * type, validated against `STAPEL_CDN["ASSET_TYPES"]`.
+     *
+     * Refuses `error.400.invalid_image_type` for a type this deployment does not
+     * declare. Note the asymmetry with {@link uploadImage}, which writes
+     * `"product"` without consulting that setting at all: on a default
+     * deployment `POST /images/product/upload/` is a 400 while
+     * `POST /upload/image/` happily stores a `product` row. A host that wants
+     * `product` addressable by name adds it to `ASSET_TYPES`.
+     */
+    uploadTypedImage(imageType: string, file: File, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<CdnImageUploadResponse>;
+    /**
+     * `POST /upload/video/`. Typed and callable; this pair ships no hook and no
+     * widget over it (the storefront MVP is images), so a host that needs video
+     * today calls it directly rather than waiting for a version of the pair that
+     * has the queue for it. Variants are not generated yet upstream — the
+     * response's `is_processed` stays false and the ladder is empty.
+     */
+    uploadVideo(file: File, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<CdnVideoUploadResponse>;
+    /**
+     * `POST /upload/file/` — documents and archives. Same status as
+     * {@link uploadVideo}: typed, callable, no hook. Its allowlist is a MIME
+     * allowlist as well as an extension one, and deliberately excludes
+     * `application/octet-stream`.
+     */
+    uploadFile(file: File, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<CdnFileUploadResponse>;
+}
+export declare function createCdnApi(client: StapelClient): CdnApi;
+//# sourceMappingURL=cdnApi.d.ts.map

package/dist/api/cdnApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdnApi.d.ts","sourceRoot":"","sources":["../../src/api/cdnApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAE9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAElC;;;;;;;;;;;OAWG;IACH,WAAW,CACT,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAEnC;;;;;;OAMG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAEnC;;;;;;;;;;OAUG;IACH,gBAAgB,CACd,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAEnC;;;;;;OAMG;IACH,WAAW,CACT,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,UAAU,CACR,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACnC;AAmBD,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CA6BzD"}

package/dist/api/cdnApi.js

@@ -0,0 +1,27 @@
+/**
+ * The one multipart body every upload endpoint takes: a single `file` part.
+ * `FormData` is a `BodyInit`, so `StapelClient` sends it verbatim and lets the
+ * browser write the `Content-Type` boundary — setting that header by hand is
+ * the classic way to make a multipart POST unparseable server-side.
+ */
+function filePart(file) {
+    const form = new FormData();
+    form.append("file", file);
+    return form;
+}
+const signalOf = (options) => options?.signal !== undefined ? { signal: options.signal } : {};
+export function createCdnApi(client) {
+    return {
+        client,
+        fileExists: (fileHash, options) => client.get("/file/exists/", {
+            query: { file_hash: fileHash },
+            ...signalOf(options),
+        }),
+        uploadImage: (file, options) => client.post("/upload/image/", filePart(file), signalOf(options)),
+        uploadAvatar: (file, options) => client.post("/upload/avatar/", filePart(file), signalOf(options)),
+        uploadTypedImage: (imageType, file, options) => client.post(`/images/${encodeURIComponent(imageType)}/upload/`, filePart(file), signalOf(options)),
+        uploadVideo: (file, options) => client.post("/upload/video/", filePart(file), signalOf(options)),
+        uploadFile: (file, options) => client.post("/upload/file/", filePart(file), signalOf(options)),
+    };
+}
+//# sourceMappingURL=cdnApi.js.map

package/dist/api/cdnApi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdnApi.js","sourceRoot":"","sources":["../../src/api/cdnApi.ts"],"names":[],"mappings":"AA4IA;;;;;GAKG;AACH,SAAS,QAAQ,CAAC,IAAU;IAC1B,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;IAC5B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC1B,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,QAAQ,GAAG,CAAC,OAEjB,EAA4B,EAAE,CAC7B,OAAO,EAAE,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAElE,MAAM,UAAU,YAAY,CAAC,MAAoB;IAC/C,OAAO;QACL,MAAM;QAEN,UAAU,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,CAChC,MAAM,CAAC,GAAG,CAAC,eAAe,EAAE;YAC1B,KAAK,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE;YAC9B,GAAG,QAAQ,CAAC,OAAO,CAAC;SACrB,CAAC;QAEJ,WAAW,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAC7B,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QAElE,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAC9B,MAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QAEnE,gBAAgB,EAAE,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAC7C,MAAM,CAAC,IAAI,CACT,WAAW,kBAAkB,CAAC,SAAS,CAAC,UAAU,EAClD,QAAQ,CAAC,IAAI,CAAC,EACd,QAAQ,CAAC,OAAO,CAAC,CAClB;QAEH,WAAW,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAC7B,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QAElE,UAAU,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAC5B,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;KAClE,CAAC;AACJ,CAAC"}