@camstack/shm-ring 0.1.2

package/binding.gyp

@@ -0,0 +1,35 @@
+{
+  "targets": [
+    {
+      "target_name": "shm_ring",
+      "sources": [ "src/shm.cc" ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "defines": [
+        "NAPI_DISABLE_CPP_EXCEPTIONS",
+        "NAPI_VERSION=8"
+      ],
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "conditions": [
+        [ "OS=='linux'", {
+          "libraries": [ "-lrt" ]
+        } ],
+        [ "OS=='mac'", {
+          "xcode_settings": {
+            "CLANG_CXX_LANGUAGE_STANDARD": "c++17",
+            "MACOSX_DEPLOYMENT_TARGET": "11.0"
+          }
+        } ],
+        [ "OS=='win'", {
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "ExceptionHandling": 1
+            }
+          }
+        } ]
+      ]
+    }
+  ]
+}

package/dist/frame-ring-reader-cache.d.ts

@@ -0,0 +1,22 @@
+import { DecodedFrame, FrameHandle, IScopedLogger } from '@camstack/types';
+/**
+ * Opens (and caches) a `FrameRingReader` per `shmId` and reads the pixels a
+ * `FrameHandle` refers to. Single-consumer — one cache per frame subscription.
+ */
+export declare class FrameRingReaderCache {
+    private readonly rings;
+    private readonly logger;
+    private closed;
+    constructor(logger?: IScopedLogger);
+    /**
+     * Read the pixels a `FrameHandle` refers to and return them as a
+     * `DecodedFrame`. Returns `null` when the ring slot was recycled before the
+     * read (a dropped frame) or the segment could not be opened.
+     */
+    read(handle: FrameHandle): DecodedFrame | null;
+    /** Close every cached segment. Idempotent. */
+    close(): void;
+    /** Get the cached reader for a handle's segment, opening it on first use. */
+    private ringFor;
+}
+//# sourceMappingURL=frame-ring-reader-cache.d.ts.map

package/dist/frame-ring-reader-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-ring-reader-cache.d.ts","sourceRoot":"","sources":["../src/frame-ring-reader-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAiB/E;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,MAAM,CAAQ;gBAEV,MAAM,CAAC,EAAE,aAAa;IAIlC;;;;OAIG;IACH,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,GAAG,IAAI;IAyB9C,8CAA8C;IAC9C,KAAK,IAAI,IAAI;IAiBb,6EAA6E;IAC7E,OAAO,CAAC,OAAO;CAkChB"}

package/dist/frame-ring.d.ts

@@ -0,0 +1,379 @@
+import { FrameFormat, FrameHandle } from '@camstack/types';
+/** Per-frame metadata published alongside the pixels of a slot. */
+export interface FrameMeta {
+    readonly width: number;
+    readonly height: number;
+    readonly format: FrameFormat;
+    readonly pts: number;
+    /** Valid pixel bytes — must be `<= slotByteLength`. */
+    readonly byteLength: number;
+}
+/**
+ * A scatter-write slot reservation returned by {@link FrameRingWriter.beginFrame}.
+ *
+ * ## Scatter-write seqlock contract (Phase 5 / D9 Task 7c — READ THIS)
+ *
+ * `beginFrame()` has already bumped this slot's `seq` to **odd** — a write is in
+ * progress, so any reader hitting this slot skips it (returns `null` / a failed
+ * `validate()`). The caller now owns an exclusive write window over `buffer`:
+ *
+ *   1. `buffer` is a writable `subarray` **directly over the slot's pixel
+ *      region in the mapped segment** — there is no intermediate copy. A
+ *      producer (e.g. the node-av scaler) fills it in place.
+ *   2. The slot stays odd for the **entire fill duration** — not just a memcpy.
+ *      A scatter producer that takes longer to fill the slot (a whole scale
+ *      pass) holds the slot odd for that whole pass; this is correct, readers
+ *      simply latest-wins-drop that slot until {@link FrameRingWriter.commitFrame}.
+ *   3. The caller MUST call {@link FrameRingWriter.commitFrame} with this exact
+ *      `slot` once the fill is done — that writes the metadata, bumps `seq` back
+ *      to **even** (committed) and advances `writeIndex` so readers can see it.
+ *
+ * Exactly one `beginFrame` may be open at a time per writer (there is a single
+ * writer per ring). `buffer.byteLength` is the slot's full capacity
+ * (`slotByteLength`); the caller writes at most `commitFrame`'s `meta.byteLength`
+ * valid bytes into it.
+ */
+export interface FrameSlotWrite {
+    /** The ring slot index this write targets — pass it back to `commitFrame`. */
+    readonly slot: number;
+    /**
+     * A writable view **directly over the slot's pixel region** in the shared
+     * mapping. Fill it in place, then `commitFrame(slot, meta)`. Valid only
+     * between the `beginFrame` that produced it and its matching `commitFrame`.
+     */
+    readonly buffer: Buffer;
+}
+/**
+ * The result of a successful seqlock read.
+ *
+ * ## Buffer-lifetime contract (Phase 5 / D9 Task 7b — READ THIS)
+ *
+ * `pixels` is a view onto the **reader's reusable scratch buffer**, NOT a
+ * freshly allocated copy. The seqlock-validated pixel bytes are memcpy'd into
+ * that scratch buffer (the copy is the seqlock safety copy — the bytes survive
+ * a post-read slot recycle), but the buffer itself is reused on this reader's
+ * **next** `readHandle` / `readLatest` call.
+ *
+ * Therefore `pixels` is **valid only until this same reader's next read**:
+ *
+ *   - A consumer that processes the frame **synchronously**, fully, before it
+ *     issues another read on this reader may use `pixels` directly (borrow).
+ *   - A consumer that **retains** the frame past its next read — queues it for
+ *     async work, stores it, hands it to another tick — MUST `Buffer.from(...)`
+ *     it into its own storage at the point of retention. Holding the borrowed
+ *     `pixels` past the next read is silent corruption: the next read overwrites
+ *     the bytes in place.
+ *
+ * `meta` and `handle` are plain immutable values — safe to retain freely.
+ */
+export interface FrameRead {
+    /**
+     * The slot's pixel bytes copied into the reader's reusable scratch buffer.
+     *
+     * **Borrowed, not owned** — valid only until this reader's next
+     * `readHandle` / `readLatest`. Retain past that point ⇒ copy first
+     * (`Buffer.from(pixels)`). See the `FrameRead` doc comment.
+     */
+    readonly pixels: Buffer;
+    readonly meta: FrameMeta;
+    /** A serialisable handle for this exact frame. */
+    readonly handle: FrameHandle;
+}
+/**
+ * A **zero-copy** read: `pixels` is a `subarray` directly over the shared
+ * mapping — no memcpy at all (Phase 5 / D9 Task 7b Step 3).
+ *
+ * ## Validation contract (READ THIS — concurrency-sensitive)
+ *
+ * Because `pixels` aliases the live ring slot, a concurrent writer can recycle
+ * that slot at any moment, tearing the bytes a consumer is reading. A
+ * `FrameView` is therefore an **optimistic** read: the seqlock's *opening*
+ * check already passed (the slot was committed and, for a handle read, the seq
+ * matched), but the closing re-check is deferred to the consumer.
+ *
+ * A consumer MUST:
+ *   1. read the slot **synchronously and fast** — no `await`, no yielding;
+ *   2. call `validate()` **immediately after** finishing with `pixels`;
+ *   3. if `validate()` returns `false`, **discard** whatever it computed from
+ *      `pixels` — the bytes were (or may have been) overwritten mid-read, i.e.
+ *      a torn frame, the latest-wins drop.
+ *
+ * `validate()` returning `true` means the slot's `seq` is unchanged since the
+ * read opened — the bytes the consumer just processed were a single committed
+ * frame, not torn. This is the same seqlock guarantee `readHandle` gives, but
+ * the closing half is the consumer's responsibility instead of being baked
+ * into a memcpy + recheck. Use this ONLY for tight synchronous consumers
+ * (e.g. motion's frame scan, the perf bench's compute stage); any consumer
+ * that retains or processes asynchronously MUST use the copying `readHandle` /
+ * `readLatest` instead.
+ */
+export interface FrameView {
+    /**
+     * A `subarray` view directly over the shared-memory slot — **zero-copy**.
+     * Valid for a synchronous read only; `validate()` confirms it was not torn.
+     */
+    readonly pixels: Buffer;
+    readonly meta: FrameMeta;
+    readonly handle: FrameHandle;
+    /**
+     * Re-check the slot's seqlock. `true` ⇒ the slot was not recycled while the
+     * consumer read `pixels` — the frame is intact. `false` ⇒ a torn read,
+     * discard everything derived from `pixels`. Call once, right after the
+     * synchronous read of `pixels` completes.
+     */
+    validate(): boolean;
+}
+/** Internal geometry of a sized segment. */
+interface RingGeometry {
+    readonly slotCount: number;
+    readonly slotByteLength: number;
+    /** Byte length of the `Int32Array` header. */
+    readonly headerBytes: number;
+    /** Byte offset of the metadata region. */
+    readonly metaOffset: number;
+    /** Byte offset of the pixel region. */
+    readonly pixelsOffset: number;
+    /** Total segment byte length. */
+    readonly totalBytes: number;
+}
+/**
+ * Total byte length a segment must have to hold a `slotCount`-slot ring with
+ * `slotByteLength`-byte pixel slots. The decoder uses this to size the
+ * shared-memory segment before constructing a `FrameRingWriter` over it.
+ */
+export declare function computeSegmentSize(slotCount: number, slotByteLength: number): number;
+/**
+ * Slot-count bounds for a per-resolution ring. {@link deriveSlotCount} clamps
+ * the budget-derived count into `[MIN_RING_SLOTS, MAX_RING_SLOTS]`:
+ *  - `MIN` keeps a tiny floor even when one frame nearly exhausts the budget
+ *    (a 4K RGB frame is ~24.9 MB — a 128 MB budget yields only ~5 raw slots);
+ *  - `MAX` caps the ring for small frames so a 360p stream does not allocate
+ *    hundreds of slots' worth of shared memory it will never use latest-wins.
+ */
+export declare const MIN_RING_SLOTS = 6;
+export declare const MAX_RING_SLOTS = 64;
+/**
+ * Slot count for a ring, derived from a per-ring shared-memory budget.
+ *
+ * `budgetBytes` is the shared memory a single stream's ring may consume; the
+ * raw count is `floor(budgetBytes / slotByteLength)`, clamped into
+ * `[MIN_RING_SLOTS, MAX_RING_SLOTS]`. Live video is latest-wins, so the slot
+ * count only needs to absorb the writer-commit / reader-read window — the
+ * budget trades shared-memory footprint against that window per resolution.
+ */
+export declare function deriveSlotCount(budgetBytes: number, slotByteLength: number): number;
+/**
+ * Bytes per pixel for each packed decode format a frame ring slot can hold.
+ *
+ * This is the single source of truth shared by the decoder write side
+ * (`DecoderFrameRingSink`) and every consumer read side
+ * (`FrameRingReaderCache`): if the two computed different values, a reader
+ * would mis-map the shared-memory segment and read corrupt pixels.
+ *
+ * `jpeg` has no fixed bytes-per-pixel — `computeSlotByteLength` short-circuits
+ * it to the equivalent RGB24 raster before this is ever consulted, so the `3`
+ * here is only a safe placeholder for exhaustiveness over `FrameFormat`.
+ */
+export declare function bytesPerPixel(format: FrameFormat): number;
+/**
+ * Per-slot byte capacity for a frame of the given geometry — the single source
+ * of truth for both the decoder write side and the consumer read side.
+ *
+ * For raw formats this is exactly `width × height × bpp`. For `jpeg` (variable
+ * length) the slot is sized to the equivalent RGB24 raster — a JPEG is always
+ * far smaller than its source raster, so an RGB24-sized slot is a safe upper
+ * bound. Note: this upper bound holds only while the JPEG encoder is pinned to
+ * its current quality (~80). A near-lossless quality setting can produce a
+ * JPEG that exceeds the RGB24 byte count; if quality is raised significantly,
+ * this slot size must be revisited.
+ */
+export declare function computeSlotByteLength(width: number, height: number, format: FrameFormat): number;
+/**
+ * Shared geometry + typed views over a segment buffer. The header is an
+ * `Int32Array` so `Atomics` ops apply directly; metadata and pixels are read
+ * and written through `DataView` / `Buffer` slices.
+ */
+declare abstract class FrameRingBase {
+    protected readonly segment: Buffer;
+    protected readonly shmId: string;
+    protected readonly geometry: RingGeometry;
+    /** `Int32Array` over the header — slotCount, slotByteLength, writeIndex, seq[]. */
+    protected readonly header: Int32Array;
+    protected readonly view: DataView;
+    protected constructor(segment: Buffer, shmId: string, slotCount: number, slotByteLength: number);
+    /** Header index of `seq[slot]`. */
+    protected seqIndex(slot: number): number;
+    /** Byte offset of slot `slot`'s metadata struct. */
+    protected metaOffsetOf(slot: number): number;
+    /** Byte offset of slot `slot`'s pixel region. */
+    protected pixelOffsetOf(slot: number): number;
+}
+/**
+ * The single writer for a ring. Constructed by whoever owns the segment (the
+ * decoder). On construction it stamps `slotCount` / `slotByteLength` into the
+ * header so a reader opening the same segment can self-describe.
+ */
+export declare class FrameRingWriter extends FrameRingBase {
+    /** Slot index of an in-flight `beginWrite()`, or `null` when idle. */
+    private pendingSlot;
+    /** Cluster node id stamped into every `FrameHandle` this writer produces. */
+    private readonly nodeId;
+    constructor(segment: Buffer, shmId: string, slotCount: number, slotByteLength: number, nodeId: string);
+    /** The number of slots in this ring — derived per-resolution from the budget. */
+    get slotCount(): number;
+    /** The slot the next `writeFrame` / `beginFrame` will target. */
+    private targetSlot;
+    /**
+     * Open the seqlock on the next slot and hand the caller a writable view
+     * directly over that slot's pixel region — the **scatter-write** entry point.
+     *
+     * The seqlock contract (see {@link FrameSlotWrite}): this bumps the slot's
+     * `seq` to **odd** (write in progress), so a concurrent reader skips the slot
+     * for the entire fill window. The caller fills `buffer` in place — there is
+     * NO intermediate copy: a producer (the node-av scaler) writes its packed
+     * output straight into the mapped segment — then MUST call
+     * {@link commitFrame} with the returned `slot` to publish the frame.
+     *
+     * Exactly one `beginFrame` may be open per writer at a time.
+     */
+    beginFrame(): FrameSlotWrite;
+    /**
+     * Close the seqlock opened by {@link beginFrame}: write the metadata, bump
+     * `seq` back to **even** (committed) and advance `writeIndex` so readers see
+     * this slot as the latest. Returns the published frame's `FrameHandle`.
+     *
+     * `slot` must be the value from the matching `beginFrame`'s
+     * {@link FrameSlotWrite}. The pixels are assumed already filled in place by
+     * the caller (the scatter-write contract) — `commitFrame` copies nothing.
+     */
+    commitFrame(slot: number, meta: FrameMeta): FrameHandle;
+    /**
+     * Abandon the seqlock opened by {@link beginFrame} **without publishing the
+     * slot** — the degenerate-path counterpart of {@link commitFrame}.
+     *
+     * `beginFrame` has bumped the slot's `seq` to **odd**. A caller that opened a
+     * slot but then could not fill it with valid pixels (the producer failed, or
+     * there were no source planes) MUST NOT `commitFrame` — that would close the
+     * seqlock over uninitialised / stale shared-memory bytes and advance
+     * `writeIndex`, so a reader would see those garbage bytes as a real, latest
+     * frame. `abortFrame` instead:
+     *
+     *   1. bumps `seq` from odd back to **even** — the slot is not left stuck
+     *      odd, so the writer can reuse it on a later cycle;
+     *   2. does **NOT** advance `writeIndex` — `readLatest` therefore never
+     *      surfaces this slot as the latest (the prior latest stays latest);
+     *   3. returns no `FrameHandle` — nothing is handed downstream.
+     *
+     * The slot's pixel bytes after `abortFrame` are **undefined** (whatever was
+     * there before, or a half-written producer output) — but that is harmless
+     * because no consumer ever sees the slot as committed: `readLatest` skips it
+     * (writeIndex did not move) and any handle that happened to point at this
+     * slot from an earlier commit sees the changed `seq` and is correctly
+     * rejected by `readHandle`'s seq check.
+     *
+     * `slot` must be the value from the matching `beginFrame` — validated
+     * exactly as {@link commitFrame} does.
+     */
+    abortFrame(slot: number): void;
+    /**
+     * Publish one frame from a caller-provided pixel `Buffer` — the convenience
+     * wrapper over the scatter-write {@link beginFrame} / {@link commitFrame}
+     * pair: it opens the slot, copies `pixels` into it, then commits.
+     *
+     * Prefer the `beginFrame` / `commitFrame` pair when the pixels can be
+     * produced directly into the slot (the node-av scaler scattering its packed
+     * output into the mapped segment) — that path has zero write-side copy.
+     * `writeFrame` keeps the single-call form for callers that already hold a
+     * detached pixel `Buffer`.
+     */
+    writeFrame(pixels: Buffer, meta: FrameMeta): FrameHandle;
+}
+/**
+ * A reader for a ring. Many readers may share a segment concurrently with the
+ * single writer. Every read is a seqlock read — a torn or recycled slot is
+ * dropped (returns `null`), never returned as garbage pixels.
+ */
+export declare class FrameRingReader extends FrameRingBase {
+    /**
+     * The reusable per-reader scratch buffer the seqlock-validated pixels are
+     * copied into — see the `FrameRead` doc comment for the borrow contract.
+     *
+     * Sized to `slotByteLength` on construction (the segment's stamped slot
+     * capacity) and lazily grown if a slot ever reports a larger `byteLength`.
+     * Reusing one buffer per reader replaces the per-read `Buffer.allocUnsafe` —
+     * the D9 perf gate's regression (Task 7b): a fresh ~5.93 MB allocation per
+     * 1080p frame churned ~1.39 GB/s and stalled on GC. The single memcpy stays
+     * (it IS the seqlock safety copy); only the allocation is removed.
+     */
+    private scratch;
+    /**
+     * Cluster node id of the node that OWNS this segment (i.e. the writer's
+     * node — the node whose shared memory physically holds the ring), stamped
+     * into every `FrameHandle` this reader produces. `FrameHandle.nodeId` always
+     * identifies the segment-owning node, never the reading node, so callers
+     * pass the writer's node id here (e.g. `FrameRingReaderCache` passes
+     * `handle.nodeId` straight through).
+     */
+    private readonly nodeId;
+    constructor(segment: Buffer, shmId: string, slotCount: number, slotByteLength: number, 
+    /**
+     * Node id of the segment-owning (writer's) node — see the `nodeId` field
+     * doc. NOT this reader's own node.
+     */
+    nodeId: string);
+    /**
+     * Return the reader's scratch buffer as a view of exactly `byteLength` bytes,
+     * growing the backing buffer first if a slot ever exceeds the stamped slot
+     * capacity (defensive — `slotByteLength` should always bound `byteLength`).
+     */
+    private scratchFor;
+    /**
+     * Read the latest committed frame, latest-wins. Returns `null` when the ring
+     * is empty (no frame ever published) or the latest slot is mid-write /
+     * recycled (a slow reader simply drops that frame and retries next tick).
+     *
+     * The returned `FrameRead.pixels` is **borrowed** from this reader's reusable
+     * scratch buffer — valid only until this reader's next read. A consumer that
+     * retains it past the next read MUST copy. See the `FrameRead` doc comment.
+     */
+    readLatest(): FrameRead | null;
+    /**
+     * Read the exact frame a `FrameHandle` refers to. Returns `null` when the
+     * slot has been recycled (its committed `seq` no longer matches `handle.seq`)
+     * or is mid-write — i.e. the frame is gone, not torn.
+     *
+     * The returned `FrameRead.pixels` is **borrowed** from this reader's reusable
+     * scratch buffer — valid only until this reader's next read. A consumer that
+     * retains it past the next read MUST copy. See the `FrameRead` doc comment.
+     */
+    readHandle(handle: FrameHandle): FrameRead | null;
+    /**
+     * The seqlock read of a single slot.
+     *
+     * `expectedSeq` is the committed seq a `readHandle` caller demands; pass
+     * `null` for `readLatest`, which accepts whatever even seq it finds.
+     */
+    private seqlockRead;
+    /**
+     * Read the latest committed frame **zero-copy** — `FrameView.pixels` is a
+     * `subarray` over the shared mapping, no memcpy. The caller MUST process it
+     * synchronously and then call `validate()`; see the `FrameView` contract.
+     * Returns `null` when the ring is empty or the latest slot is mid-write.
+     */
+    readLatestView(): FrameView | null;
+    /**
+     * Read the frame a `FrameHandle` refers to **zero-copy** — `FrameView.pixels`
+     * is a `subarray` over the shared mapping, no memcpy. The caller MUST process
+     * it synchronously and then call `validate()`; see the `FrameView` contract.
+     * Returns `null` when the slot is recycled (seq mismatch) or mid-write.
+     */
+    readHandleView(handle: FrameHandle): FrameView | null;
+    /**
+     * The zero-copy half of the seqlock read: validate the opening seqlock, then
+     * return a `subarray` over the slot plus a `validate()` closure that re-reads
+     * the seqlock. No pixel copy — the consumer owns the closing recheck.
+     */
+    private seqlockReadView;
+}
+export {};
+//# sourceMappingURL=frame-ring.d.ts.map

package/dist/frame-ring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-ring.d.ts","sourceRoot":"","sources":["../src/frame-ring.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@camstack/shm-ring` — cross-platform shared-memory frame plane.
+ *
+ * Public surface:
+ *  - the native segment wrapper (`createSegment` / `openSegment` / `unlinkSegment`);
+ *  - `FrameRing` (the seqlock ring) — added in Task 2.
+ */
+export { createSegment, openSegment, unlinkSegment, } from './native.js';
+export type { ShmSegment, NativeSegmentHandle } from './native.js';
+export { FrameRingWriter, FrameRingReader, computeSegmentSize, bytesPerPixel, computeSlotByteLength, deriveSlotCount, MIN_RING_SLOTS, MAX_RING_SLOTS, } from './frame-ring.js';
+export type { FrameMeta, FrameRead, FrameView, FrameSlotWrite } from './frame-ring.js';
+export { FrameRingReaderCache } from './frame-ring-reader-cache.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,aAAa,EACb,WAAW,EACX,aAAa,GACd,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAClE,OAAO,EACL,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,cAAc,GACf,MAAM,iBAAiB,CAAA;AACxB,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA"}