@beyondwork/docx-react-component 1.0.57 → 1.0.58

package/README.md

@@ -238,7 +238,7 @@ Engineering work is organized into 9 lanes (5 active now + 2 later polish + 2 fi
 | 6b | [**Shell & Workspace Chrome**](docs/plans/lane-6b-shell-workspace-chrome.md) | **~15%** | Gated on 6a.S1+S2 — shell header + toolbar + status + alert banner + unsaved modal + collab chrome restyle; mode-dock decommission; TwCommandPalette |
 | 6c | [**Context & Review Surfaces**](docs/plans/lane-6c-context-review-surfaces.md) | **~15%** | Gated on 6a.S1+S2 — selection toolbar + suggestion card + rail + scope + context toolbars + health panel restyle; TwCommentPreview / TwEmptyState / TwShortcutHint |
 | 6d | [**Visual Fidelity**](docs/plans/lane-6d-visual-fidelity.md) | **~20%** | Gated on 6a.S1+S2 + external-lane deps — L8 A/B/C shipped; L8 Phase D + P11 overlays + P7 + P12 + P14 next |
-| 7a | [**Visual Fidelity Register**](docs/plans/lane-7a-visual-fidelity-register.md) | **0%** | LATER (gated on 6a–6d) — V5 covers, V6 REF/PAGEREF, V7 cascade audit |
+| 7a | [**Visual Fidelity Register**](docs/plans/lane-7a-visual-fidelity-register.md) | **✅ 100%** | CLOSED — V5 covers (`6f8869b7`), V6 REF/PAGEREF baseline via CO3 + contract pin (`99b66a1f`), V7 × CO1 5-combo cascade audit (`df315488`) |
 | 7b | [**Revision & Redline Completion**](docs/plans/lane-7b-revision-redline-completion.md) | **0%** | LATER (gated on 6a–6d) — X4.a/b structural table revisions, X5 ffData, move-pairing |
 | 7c | [**Preservation & Format Coverage**](docs/plans/lane-7c-preservation-format-coverage.md) | **0%** | LATER (gated on 6a–6d) — O6 Strict, OLE preserve-only, picture-SDT, w14/kern/VML defer |
 | 7d | [**Platform Hardening & Hygiene**](docs/plans/lane-7d-platform-hardening-hygiene.md) | **0%** | LATER (gated on 6a–6d) — harness-crash-hardening, fastload activation, worktree consolidation |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@beyondwork/docx-react-component",
   "publisher": "beyondwork",
-  "version": "1.0.57",
+  "version": "1.0.58",
   "description": "Embeddable React Word (docx) editor with review, comments, tracked changes, and round-trip OOXML fidelity.",
   "packageManager": "pnpm@10.30.3",
   "type": "module",

package/src/api/public-types.ts

@@ -482,6 +482,12 @@ export interface SearchOptions {
   matchCase?: boolean;
   wholeWord?: boolean;
   limit?: number;
+  /** Phase C §C3 — treat `query` as a JS regex pattern (compiled with `u` flag). */
+  regex?: boolean;
+  /** Phase C §C3 — restrict results to positions inside this scopeId's marker range. */
+  inScope?: string;
+  /** Phase C §C3 — restrict results to a specific story target (default: main). */
+  inStory?: EditorStoryTarget;
 }
 
 export interface SearchResultSnapshot {
@@ -841,6 +847,12 @@ export interface SurfacePictureEffects {
   flipV?: boolean;
   presetGeom?: string;
   stretch?: boolean;
+  /** N11.b — a:softEdge feather radius in EMU. Maps to CSS `filter: blur(R)`. */
+  softEdgeRadius?: number;
+  /** N11.b — a:outerShdw drop shadow. `blurRad`/`dist` in EMU; `dir` in 60000ths of a degree. */
+  outerShadow?: { blurRad: number; dist: number; dir: number; color: string; colorType: "srgbClr" | "schemeClr" };
+  /** N11.b — a:glow ambient glow. `radius` in EMU. */
+  glow?: { radius: number; color: string; colorType: "srgbClr" | "schemeClr" };
 }
 
 export type SurfaceInlineSegment =
@@ -1812,6 +1824,8 @@ export interface RuntimeRenderSnapshot {
   commandState: CommandStateSnapshot;
   surface?: EditorSurfaceSnapshot;
   protectionSnapshot: ProtectionSnapshot;
+  /** R.3 — stable id of the currently grabbed image/shape, or null. Populated from grab state so chrome overlays re-render on selectObject/deselectObject. */
+  grabbedObjectId?: string | null;
 }
 
 export interface EditorSessionState {
@@ -2042,6 +2056,67 @@ export interface WorkflowMetadataSnapshot {
   entries: WorkflowMetadataEntry[];
 }
 
+// ---------------------------------------------------------------------------
+// Phase C — host-side scope query surface (§C1, §C2)
+// ---------------------------------------------------------------------------
+
+/**
+ * §C1 — Filter passed to `queryScopes` / `findScopesAt` /
+ * `findScopesIntersecting`. All fields are optional and AND'd together.
+ * Snapshot-based; never triggers runtime mutation.
+ */
+export interface ScopeQueryFilter {
+  /** Match only scopes attached to any of these work items. */
+  workItemIds?: string[];
+  /** Match only scopes in one of these modes. */
+  modes?: WorkflowScopeMode[];
+  /** Match only scopes whose `domain` is one of these. */
+  domains?: Array<NonNullable<WorkflowScope["domain"]>>;
+  /**
+   * Match scopes that carry at least one entry with this `metadataId`.
+   * Uses the runtime `WorkflowMetadataSnapshot` joined by `entry.scopeId`.
+   */
+  metadataId?: string;
+  /**
+   * Match scopes that carry at least one entry whose `value` passes the
+   * predicate. Entries with no `value` are skipped.
+   */
+  hasValue?: (value: Record<string, unknown>, entry: WorkflowMetadataEntry) => boolean;
+  /** Label prefix (case-insensitive). */
+  labelPrefix?: string;
+  /**
+   * Story target filter. Defaults to `{ kind: "main" }` when omitted. Pass
+   * `"*"` for any story.
+   */
+  storyTarget?: EditorStoryTarget | "*";
+  /** Max result count. Undefined = no cap. */
+  limit?: number;
+  /**
+   * §C8 — include scopes with `visibility: "hidden"`. Default: false.
+   * Accepted but has no effect until §C8 adds the `visibility` field.
+   */
+  includeHidden?: boolean;
+  /**
+   * §C8 — include scopes with `visibility: "invisible"`. Default: false.
+   * Accepted but has no effect until §C8 adds the `visibility` field.
+   */
+  includeInvisible?: boolean;
+}
+
+/**
+ * §C1 — One result from `queryScopes`. Joins the scope record with the
+ * metadata entries that point at it and the resolved work item (when
+ * `scope.workItemId` matches one in the overlay).
+ */
+export interface ScopeQueryResult {
+  /** Scope record from the overlay. */
+  scope: WorkflowScope;
+  /** Metadata entries whose `entry.scopeId === scope.scopeId`. */
+  entries: WorkflowMetadataEntry[];
+  /** Resolved work item when `scope.workItemId` is set and present. */
+  workItem: WorkflowWorkItem | null;
+}
+
 // ---------------------------------------------------------------------------
 // R2 — issue metadata (scope-card-overlay P1)
 // ---------------------------------------------------------------------------
@@ -3326,6 +3401,86 @@ export interface WordReviewEditorRef {
   setWorkflowMetadataEntries(entries: WorkflowMetadataEntry[]): void;
   clearWorkflowMetadataEntries(): void;
   getWorkflowMetadataSnapshot(): WorkflowMetadataSnapshot;
+  /**
+   * Phase C §C1 — filter + project the current workflow overlay into a
+   * scope-joined view. Reads a snapshot of the current overlay + metadata
+   * entries + work items; no mutation. Results are sorted by start-marker
+   * document position, tie-broken by `scopeId` ascending.
+   *
+   * Defaults: `storyTarget` = `{ kind: "main" }` (pass `"*"` for any
+   * story); `includeHidden` / `includeInvisible` default to `false`
+   * (§C8 additive — accepted today but no-ops until `visibility` lands).
+   *
+   * Returns `[]` when no workflow overlay has been set.
+   */
+  queryScopes(filter?: ScopeQueryFilter): ScopeQueryResult[];
+  /**
+   * Phase C §C2 — every scope whose marker range contains `position.from`
+   * (end-inclusive), ordered outermost → innermost. Pass a zero-length
+   * range (`from === to`) for a point query. Returns the full
+   * `ScopeQueryResult` (scope + entries + workItem) so results compose
+   * directly with `setSelection`, `addScope`, `getLocationForAnchor`.
+   *
+   * Companion to `getInteractionGuardSnapshot().matchedScopeId` — that
+   * API returns the innermost-only match; this one returns the whole
+   * enclosing stack.
+   */
+  findScopesAt(
+    position: EditorAnchorProjection,
+    options?: { includeHidden?: boolean; includeInvisible?: boolean },
+  ): ScopeQueryResult[];
+  /**
+   * Phase C §C2 — every scope whose marker range intersects `range`
+   * (accepts a range anchor; non-range anchors yield `[]`). Default
+   * `mode: "overlap"` matches any intersection including touching
+   * endpoints; `mode: "contain"` requires the scope's entire range to
+   * sit within `range`. Deterministic order by start-marker position.
+   */
+  findScopesIntersecting(
+    range: EditorAnchorProjection,
+    options?: {
+      includeHidden?: boolean;
+      includeInvisible?: boolean;
+      mode?: "overlap" | "contain";
+    },
+  ): ScopeQueryResult[];
+  /**
+   * Phase C §C3 — find the first text match in the document.
+   * Supports `regex`, `inScope`, `inStory` options.
+   * Throws `EditorApiError({ code: "search_invalid_regex" })` synchronously
+   * when `options.regex === true` and `query` is not a valid regex pattern.
+   * Returns `null` when no match is found.
+   */
+  findFirstText(
+    query: string,
+    options?: SearchOptions,
+  ): EditorAnchorProjection | null;
+  /**
+   * Phase C §C3 — find all text matches in the document.
+   * Same options and error contract as `findFirstText`.
+   * Returns `[]` when no matches are found.
+   */
+  findAllText(
+    query: string,
+    options?: SearchOptions,
+  ): EditorAnchorProjection[];
+  /**
+   * Phase C §C3 — find first text match and select it. Returns `true` if a
+   * match was found (and selection updated), `false` otherwise.
+   */
+  selectFirstText(
+    query: string,
+    options?: SearchOptions,
+  ): boolean;
+  /**
+   * Phase C §C3 — select first text match and return the total match count.
+   * Returns `0` when no matches are found. Multi-range selection deferred
+   * to Lane 1 shipping `SelectionSnapshot.multi`.
+   */
+  selectAllText(
+    query: string,
+    options?: SearchOptions,
+  ): number;
   /**
    * Schema 1.1 — set the overlay default for metadata persistence.
    * Author-only per collab-master-plan §7 role-gating matrix;
@@ -3863,6 +4018,24 @@ export interface ResolveMetadataConflictInput {
 }
 
 // ---------------------------------------------------------------------------
+// Phase C §C3 — generic editor API error
+// ---------------------------------------------------------------------------
+
+/**
+ * Thrown synchronously by query methods when the caller passes an invalid
+ * argument. The `code` field identifies the specific failure:
+ * - `"search_invalid_regex"` — `options.regex === true` and `query` is not
+ *   a valid JavaScript regular expression pattern.
+ */
+export class EditorApiError extends Error {
+  readonly code: string;
+  constructor(params: { code: string; message?: string }) {
+    super(params.message ?? `EditorApiError: ${params.code}`);
+    this.name = "EditorApiError";
+    this.code = params.code;
+  }
+}
+
 // Schema 1.1 — metadata-persistence errors (P17)
 // ---------------------------------------------------------------------------
 

package/src/io/ooxml/parse-picture.ts

@@ -60,6 +60,17 @@ export function parsePicture(graphicDataEl: XmlElementNode): PictureContent | nu
   const prstGeom = spPr ? findFirstChild(spPr, "prstGeom") : undefined;
   const presetGeom = prstGeom?.attributes.prst;
 
+  // N11.b — effectLst: softEdge, outerShdw, glow
+  const effectLst = spPr ? findFirstChild(spPr, "effectLst") : undefined;
+  const softEdgeEl = effectLst ? findFirstChild(effectLst, "softEdge") : undefined;
+  const softEdgeRadius = softEdgeEl ? readEmuAttr(softEdgeEl, "rad") : undefined;
+  const outerShdwEl = effectLst ? findFirstChild(effectLst, "outerShdw") : undefined;
+  const outerShadow = outerShdwEl
+    ? parseOuterShadow(outerShdwEl)
+    : undefined;
+  const glowEl = effectLst ? findFirstChild(effectLst, "glow") : undefined;
+  const glow = glowEl ? parseGlow(glowEl) : undefined;
+
   const result: PictureContent = { type: "picture", blipRef };
   if (srcRect) result.srcRect = srcRect;
   if (stretch !== undefined) result.stretch = stretch;
@@ -67,9 +78,49 @@ export function parsePicture(graphicDataEl: XmlElementNode): PictureContent | nu
   if (flipH !== undefined) result.flipH = flipH;
   if (flipV !== undefined) result.flipV = flipV;
   if (presetGeom) result.presetGeom = presetGeom;
+  if (softEdgeRadius !== undefined) result.softEdgeRadius = softEdgeRadius;
+  if (outerShadow) result.outerShadow = outerShadow;
+  if (glow) result.glow = glow;
   return result;
 }
 
+function readEmuAttr(el: XmlElementNode, name: string): number | undefined {
+  const v = el.attributes[name];
+  if (v === undefined) return undefined;
+  const n = parseInt(v, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function parseColorFromEl(el: XmlElementNode): { color: string; colorType: "srgbClr" | "schemeClr" } | null {
+  const srgb = findFirstChild(el, "srgbClr");
+  if (srgb) {
+    return { color: (srgb.attributes.val ?? "000000").toUpperCase(), colorType: "srgbClr" };
+  }
+  const scheme = findFirstChild(el, "schemeClr");
+  if (scheme) {
+    return { color: scheme.attributes.val ?? "dk1", colorType: "schemeClr" };
+  }
+  return null;
+}
+
+function parseOuterShadow(
+  el: XmlElementNode,
+): PictureContent["outerShadow"] {
+  const blurRad = readEmuAttr(el, "blurRad") ?? 0;
+  const dist = readEmuAttr(el, "dist") ?? 0;
+  const dir = parseInt(el.attributes.dir ?? "0", 10) || 0;
+  const colorInfo = parseColorFromEl(el);
+  if (!colorInfo) return undefined;
+  return { blurRad, dist, dir, color: colorInfo.color, colorType: colorInfo.colorType };
+}
+
+function parseGlow(el: XmlElementNode): PictureContent["glow"] {
+  const radius = readEmuAttr(el, "rad") ?? 0;
+  const colorInfo = parseColorFromEl(el);
+  if (!colorInfo) return undefined;
+  return { radius, color: colorInfo.color, colorType: colorInfo.colorType };
+}
+
 function readPercentAttr(el: XmlElementNode, name: string): number {
   const v = el.attributes[name];
   if (v === undefined) return 0;

package/src/model/canonical-document.ts

@@ -1478,6 +1478,12 @@ export interface PictureContent {
   flipH?: boolean;
   flipV?: boolean;
   presetGeom?: string;
+  /** N11.b — DrawingML a:softEdge feather radius in EMU. */
+  softEdgeRadius?: number;
+  /** N11.b — DrawingML a:outerShdw attributes. `dir` is in 60000ths of a degree; `blurRad`/`dist` in EMU. */
+  outerShadow?: { blurRad: number; dist: number; dir: number; color: string; colorType: "srgbClr" | "schemeClr" };
+  /** N11.b — DrawingML a:glow radius in EMU + color. */
+  glow?: { radius: number; color: string; colorType: "srgbClr" | "schemeClr" };
   /** Original w:drawing XML slice, preserved for lossless round-trip serialization. */
   rawXml?: string;
 }

package/src/runtime/document-runtime.ts

@@ -86,6 +86,8 @@ import type {
   WorkflowOverlay,
   WorkflowScope,
   WorkflowScopeSnapshot,
+  ScopeQueryFilter,
+  ScopeQueryResult,
   WorkspaceMode,
   WordReviewEditorEvent,
   ZoomLevel,
@@ -136,7 +138,16 @@ import {
 } from "../review/store/revision-store.ts";
 import { createSuggestionsSnapshot } from "./suggestions-snapshot.ts";
 import { validateSelectionAgainstDocument } from "./selection/post-edit-validator.ts";
-import { collectScopeLocations, resolveScope } from "./scope-resolver.ts";
+import {
+  collectScopeLocations,
+  findAllScopesAt,
+  findScopesIntersecting,
+  resolveScope,
+} from "./scope-resolver.ts";
+import {
+  projectScopeQueryResults,
+  queryScopes as runQueryScopes,
+} from "./query-scopes.ts";
 import {
   insertScopeMarkers,
   removeScopeMarkers,
@@ -504,6 +515,27 @@ export interface DocumentRuntime {
   setWorkflowMetadataEntries(entries: WorkflowMetadataEntry[]): void;
   clearWorkflowMetadataEntries(): void;
   getWorkflowMetadataSnapshot(): WorkflowMetadataSnapshot;
+  /**
+   * Phase C §C1 — snapshot-based filter + join projection. See
+   * `WordReviewEditorRef.queryScopes` for contract.
+   */
+  queryScopes(filter?: ScopeQueryFilter): ScopeQueryResult[];
+  /**
+   * Phase C §C2 — geometric scope queries. See `WordReviewEditorRef`
+   * for contract. Non-range anchors yield `[]`.
+   */
+  findScopesAt(
+    position: EditorAnchorProjection,
+    options?: { includeHidden?: boolean; includeInvisible?: boolean },
+  ): ScopeQueryResult[];
+  findScopesIntersecting(
+    range: EditorAnchorProjection,
+    options?: {
+      includeHidden?: boolean;
+      includeInvisible?: boolean;
+      mode?: "overlap" | "contain";
+    },
+  ): ScopeQueryResult[];
   setHostAnnotationOverlay(overlay: HostAnnotationOverlay): void;
   clearHostAnnotationOverlay(): void;
   getHostAnnotationSnapshot(): HostAnnotationSnapshot;
@@ -2215,6 +2247,7 @@ export function createDocumentRuntime(
       },
       surface,
       protectionSnapshot,
+      grabbedObjectId: grabState.objectId,
     };
   }
 
@@ -3690,6 +3723,40 @@ export function createDocumentRuntime(
     getWorkflowMetadataSnapshot() {
       return deriveWorkflowMetadataSnapshot();
     },
+    queryScopes(filter) {
+      return runQueryScopes(
+        {
+          overlay: workflowOverlay,
+          entries: workflowMetadataEntries,
+          document: state.document,
+        },
+        filter,
+      );
+    },
+    findScopesAt(position, options) {
+      const pos =
+        position.kind === "range"
+          ? position.from
+          : position.kind === "node"
+            ? position.at
+            : null;
+      if (pos === null) return [];
+      const hits = findAllScopesAt(state.document, pos);
+      return projectScopeQueryResults(
+        { overlay: workflowOverlay, entries: workflowMetadataEntries, document: state.document },
+        hits.map((h) => h.scopeId),
+        options,
+      );
+    },
+    findScopesIntersecting(range, options) {
+      if (range.kind !== "range") return [];
+      const hits = findScopesIntersecting(state.document, range.from, range.to, options?.mode);
+      return projectScopeQueryResults(
+        { overlay: workflowOverlay, entries: workflowMetadataEntries, document: state.document },
+        hits.map((h) => h.scopeId),
+        options,
+      );
+    },
     setHostAnnotationOverlay(overlay) {
       this.dispatch({
         type: "host-annotation.set-overlay",

package/src/runtime/document-search.ts

@@ -1,10 +1,12 @@
 import type {
   DocumentNavigationSnapshot,
+  EditorAnchorProjection,
   EditorStoryTarget,
   SearchOptions,
   SearchResultSnapshot,
   SelectionSnapshot,
 } from "../api/public-types";
+import { EditorApiError } from "../api/public-types.ts";
 import {
   MAIN_STORY_TARGET,
   storyTargetsEqual,
@@ -23,6 +25,7 @@ import {
   resolveSectionForStoryTarget,
 } from "./document-layout.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
+import { resolveScope } from "./scope-resolver.ts";
 
 export function searchDocument(
   document: CanonicalDocumentEnvelope,
@@ -143,3 +146,61 @@ function getActiveSearchResultIndex(
 
   return activeIndex >= 0 ? activeIndex : 0;
 }
+
+/**
+ * Phase C §C3 — find all text matches in the document, respecting the new
+ * `regex`, `inScope`, and `inStory` options. Throws `EditorApiError` with
+ * `code: "search_invalid_regex"` if `options.regex === true` and `query`
+ * is not a valid JavaScript regular expression pattern.
+ *
+ * Returns an array of `EditorAnchorProjection` values (range anchors) that
+ * compose directly with `setSelection`, `addScope`, `getLocationForAnchor`.
+ */
+export function findTextMatches(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  query: string,
+  options: SearchOptions = {},
+): EditorAnchorProjection[] {
+  const normalizedQuery = query.trim();
+  if (!normalizedQuery) return [];
+
+  if (options.regex) {
+    try {
+      const flags = options.matchCase ? "ug" : "uig";
+      new RegExp(normalizedQuery, flags);
+    } catch {
+      throw new EditorApiError({
+        code: "search_invalid_regex",
+        message: `Invalid regex pattern: ${normalizedQuery}`,
+      });
+    }
+  }
+
+  const storyTarget: EditorStoryTarget = options.inStory ?? MAIN_STORY_TARGET;
+  const surface = createEditorSurfaceSnapshot(
+    document,
+    createSelectionSnapshot(selection.anchor, selection.head),
+    storyTarget,
+  );
+
+  let results = searchSurfaceBlocks(surface.blocks, normalizedQuery, options);
+
+  if (options.inScope) {
+    const scopeAnchor = resolveScope(document, options.inScope);
+    if (!scopeAnchor || scopeAnchor.kind !== "range") {
+      return [];
+    }
+    const { from: scopeFrom, to: scopeTo } = scopeAnchor;
+    results = results.filter(
+      (r) => r.from >= scopeFrom && r.to <= scopeTo,
+    );
+  }
+
+  return results.map((r) => ({
+    kind: "range" as const,
+    from: r.from,
+    to: r.to,
+    assoc: { start: -1 as const, end: 1 as const },
+  }));
+}

package/src/runtime/query-scopes.ts

@@ -0,0 +1,186 @@
+import type {
+  EditorStoryTarget,
+  ScopeQueryFilter,
+  ScopeQueryResult,
+  WorkflowMetadataEntry,
+  WorkflowOverlay,
+  WorkflowScope,
+  WorkflowWorkItem,
+} from "../api/public-types.ts";
+import type { CanonicalDocument } from "../model/canonical-document.ts";
+import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
+import { collectScopeLocations } from "./scope-resolver.ts";
+
+function storyTargetsEqual(a: EditorStoryTarget, b: EditorStoryTarget): boolean {
+  if (a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case "main":
+      return true;
+    case "header":
+    case "footer":
+      return (
+        a.relationshipId === (b as typeof a).relationshipId &&
+        a.variant === (b as typeof a).variant &&
+        a.sectionIndex === (b as typeof a).sectionIndex
+      );
+    case "footnote":
+    case "endnote":
+      return a.noteId === (b as typeof a).noteId;
+  }
+}
+
+const MAIN_STORY: EditorStoryTarget = { kind: "main" };
+
+export interface ScopeQueryInputs {
+  readonly overlay: WorkflowOverlay | null;
+  readonly entries: readonly WorkflowMetadataEntry[];
+  readonly document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope;
+}
+
+/**
+ * Phase C §C2 helper — project an ordered list of scopeIds (already produced
+ * by a geometric walk like `findAllScopesAt` / `findScopesIntersecting`)
+ * into `ScopeQueryResult[]`. Preserves incoming order. Filters out scopeIds
+ * that are not in the overlay (e.g. orphan markers). Applies the §C8
+ * visibility filter via `includeHidden` / `includeInvisible`.
+ */
+export function projectScopeQueryResults(
+  inputs: ScopeQueryInputs,
+  scopeIds: readonly string[],
+  options: { includeHidden?: boolean; includeInvisible?: boolean } = {},
+): ScopeQueryResult[] {
+  const overlay = inputs.overlay;
+  if (!overlay) return [];
+  const includeHidden = options.includeHidden === true;
+  const includeInvisible = options.includeInvisible === true;
+
+  const scopesById = new Map<string, WorkflowScope>();
+  for (const scope of overlay.scopes) scopesById.set(scope.scopeId, scope);
+
+  const entriesByScope = new Map<string, WorkflowMetadataEntry[]>();
+  for (const entry of inputs.entries) {
+    if (!entry.scopeId) continue;
+    let list = entriesByScope.get(entry.scopeId);
+    if (!list) {
+      list = [];
+      entriesByScope.set(entry.scopeId, list);
+    }
+    list.push(entry);
+  }
+
+  const workItemsById = new Map<string, WorkflowWorkItem>();
+  for (const item of overlay.workItems ?? []) {
+    workItemsById.set(item.workItemId, item);
+  }
+
+  const results: ScopeQueryResult[] = [];
+  for (const scopeId of scopeIds) {
+    const scope = scopesById.get(scopeId);
+    if (!scope) continue;
+    const visibility = (scope as WorkflowScope & { visibility?: string }).visibility;
+    if (visibility === "hidden" && !includeHidden) continue;
+    if (visibility === "invisible" && !includeInvisible) continue;
+    const entries = entriesByScope.get(scopeId) ?? [];
+    const workItem = scope.workItemId
+      ? workItemsById.get(scope.workItemId) ?? null
+      : null;
+    results.push({ scope, entries, workItem });
+  }
+  return results;
+}
+
+/**
+ * Pure §C1 projector — filter + join scopes with entries + workItem, ordered
+ * by start-marker document position (scopeId ASC tiebreak). Snapshot-based;
+ * no runtime state mutation.
+ */
+export function queryScopes(
+  inputs: ScopeQueryInputs,
+  filter: ScopeQueryFilter | undefined,
+): ScopeQueryResult[] {
+  const overlay = inputs.overlay;
+  if (!overlay) return [];
+
+  const normalizedStoryFilter = filter?.storyTarget ?? MAIN_STORY;
+  const workItemIdSet = filter?.workItemIds ? new Set(filter.workItemIds) : null;
+  const modeSet = filter?.modes ? new Set(filter.modes) : null;
+  const domainSet = filter?.domains ? new Set(filter.domains) : null;
+  const labelPrefix = filter?.labelPrefix?.toLowerCase();
+  const metadataId = filter?.metadataId;
+  const hasValue = filter?.hasValue;
+  const limit = filter?.limit;
+  const includeHidden = filter?.includeHidden === true;
+  const includeInvisible = filter?.includeInvisible === true;
+
+  const entriesByScope = new Map<string, WorkflowMetadataEntry[]>();
+  for (const entry of inputs.entries) {
+    if (!entry.scopeId) continue;
+    let list = entriesByScope.get(entry.scopeId);
+    if (!list) {
+      list = [];
+      entriesByScope.set(entry.scopeId, list);
+    }
+    list.push(entry);
+  }
+
+  const workItemsById = new Map<string, WorkflowWorkItem>();
+  for (const item of overlay.workItems ?? []) {
+    workItemsById.set(item.workItemId, item);
+  }
+
+  const locations = collectScopeLocations(inputs.document);
+
+  const candidates: Array<{ scope: WorkflowScope; startPos: number }> = [];
+  for (const scope of overlay.scopes) {
+    // §C8 pre-wire: respect visibility flags. Visibility field itself lands
+    // in §C8; treating missing as "visible" keeps this forward-compatible.
+    const visibility = (scope as WorkflowScope & { visibility?: string }).visibility;
+    if (visibility === "hidden" && !includeHidden) continue;
+    if (visibility === "invisible" && !includeInvisible) continue;
+
+    if (normalizedStoryFilter !== "*") {
+      const scopeStory = scope.storyTarget ?? MAIN_STORY;
+      if (!storyTargetsEqual(scopeStory, normalizedStoryFilter)) continue;
+    }
+    if (modeSet && !modeSet.has(scope.mode)) continue;
+    if (domainSet && !(scope.domain && domainSet.has(scope.domain))) continue;
+    if (workItemIdSet) {
+      if (!scope.workItemId || !workItemIdSet.has(scope.workItemId)) continue;
+    }
+    if (labelPrefix) {
+      const label = scope.label?.toLowerCase() ?? "";
+      if (!label.startsWith(labelPrefix)) continue;
+    }
+
+    const scopeEntries = entriesByScope.get(scope.scopeId) ?? [];
+
+    if (metadataId && !scopeEntries.some((e) => e.metadataId === metadataId)) continue;
+    if (hasValue) {
+      const anyMatch = scopeEntries.some(
+        (e) => e.value !== undefined && hasValue(e.value, e),
+      );
+      if (!anyMatch) continue;
+    }
+
+    const loc = locations.get(scope.scopeId);
+    const startPos =
+      loc?.startPos ?? loc?.endPos ?? Number.POSITIVE_INFINITY;
+    candidates.push({ scope, startPos });
+  }
+
+  candidates.sort((a, b) => {
+    if (a.startPos !== b.startPos) return a.startPos - b.startPos;
+    return a.scope.scopeId < b.scope.scopeId ? -1 : a.scope.scopeId > b.scope.scopeId ? 1 : 0;
+  });
+
+  const results: ScopeQueryResult[] = [];
+  for (const { scope } of candidates) {
+    if (limit !== undefined && results.length >= limit) break;
+    const entries = entriesByScope.get(scope.scopeId) ?? [];
+    const workItem = scope.workItemId
+      ? workItemsById.get(scope.workItemId) ?? null
+      : null;
+    results.push({ scope, entries, workItem });
+  }
+  return results;
+}

package/src/runtime/scope-resolver.ts

@@ -146,3 +146,63 @@ export function findScopeAt(
   }
   return best;
 }
+
+/**
+ * Phase C §C2 — every enclosing scope at `position`, ordered outermost →
+ * innermost (lowest startPos first; ties broken on scopeId ASC). Includes
+ * scopes that touch the position exactly (`startPos <= position <= endPos`).
+ * Companion to `findScopeAt`, which keeps the innermost-only contract.
+ */
+export function findAllScopesAt(
+  document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope,
+  position: number,
+): ResolvedScopeLocation[] {
+  const locations = collectScopeLocations(document);
+  const hits: ResolvedScopeLocation[] = [];
+  for (const [scopeId, loc] of locations) {
+    if (loc.startPos === undefined || loc.endPos === undefined) continue;
+    if (position < loc.startPos || position > loc.endPos) continue;
+    hits.push({ scopeId, startPos: loc.startPos, endPos: loc.endPos });
+  }
+  hits.sort((a, b) => {
+    if (a.startPos !== b.startPos) return a.startPos - b.startPos;
+    return a.scopeId < b.scopeId ? -1 : a.scopeId > b.scopeId ? 1 : 0;
+  });
+  return hits;
+}
+
+/**
+ * Phase C §C2 — every scope whose marker range intersects `[rangeFrom,
+ * rangeTo]`. `mode: "overlap"` (default) accepts any intersection including
+ * touching endpoints; `mode: "contain"` requires the scope's entire marker
+ * range to lie within `[rangeFrom, rangeTo]`. Deterministic order: startPos
+ * ASC, scopeId ASC.
+ */
+export function findScopesIntersecting(
+  document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope,
+  rangeFrom: number,
+  rangeTo: number,
+  mode: "overlap" | "contain" = "overlap",
+): ResolvedScopeLocation[] {
+  const from = Math.min(rangeFrom, rangeTo);
+  const to = Math.max(rangeFrom, rangeTo);
+  const locations = collectScopeLocations(document);
+  const hits: ResolvedScopeLocation[] = [];
+  for (const [scopeId, loc] of locations) {
+    if (loc.startPos === undefined || loc.endPos === undefined) continue;
+    const sFrom = Math.min(loc.startPos, loc.endPos);
+    const sTo = Math.max(loc.startPos, loc.endPos);
+    if (mode === "contain") {
+      if (sFrom < from || sTo > to) continue;
+    } else {
+      // overlap — any intersection including touching endpoints
+      if (sTo < from || sFrom > to) continue;
+    }
+    hits.push({ scopeId, startPos: loc.startPos, endPos: loc.endPos });
+  }
+  hits.sort((a, b) => {
+    if (a.startPos !== b.startPos) return a.startPos - b.startPos;
+    return a.scopeId < b.scopeId ? -1 : a.scopeId > b.scopeId ? 1 : 0;
+  });
+  return hits;
+}

package/src/runtime/surface-projection.ts

@@ -1320,7 +1320,10 @@ function surfacePictureEffectsFromContent(
     content.flipH !== undefined ||
     content.flipV !== undefined ||
     content.presetGeom !== undefined ||
-    content.stretch !== undefined;
+    content.stretch !== undefined ||
+    content.softEdgeRadius !== undefined ||
+    content.outerShadow !== undefined ||
+    content.glow !== undefined;
   if (!has) return undefined;
   return {
     ...(content.srcRect ? { srcRect: { ...content.srcRect } } : {}),
@@ -1329,6 +1332,9 @@ function surfacePictureEffectsFromContent(
     ...(content.flipV !== undefined ? { flipV: content.flipV } : {}),
     ...(content.presetGeom !== undefined ? { presetGeom: content.presetGeom } : {}),
     ...(content.stretch !== undefined ? { stretch: content.stretch } : {}),
+    ...(content.softEdgeRadius !== undefined ? { softEdgeRadius: content.softEdgeRadius } : {}),
+    ...(content.outerShadow !== undefined ? { outerShadow: { ...content.outerShadow } } : {}),
+    ...(content.glow !== undefined ? { glow: { ...content.glow } } : {}),
   };
 }
 

package/src/ui/WordReviewEditor.tsx

@@ -151,7 +151,7 @@ import {
 } from "../io/source-package-provenance.ts";
 import { readOpcPackage } from "../io/opc/package-reader.ts";
 import { deriveCapabilities } from "../runtime/session-capabilities";
-import { searchDocument } from "../runtime/document-search.ts";
+import { findTextMatches, searchDocument } from "../runtime/document-search.ts";
 import {
   resolveCurrentContextAnalyticsQuery,
   runtimeContextAnalyticsSnapshotsEqual,
@@ -909,6 +909,34 @@ export function __createWordReviewEditorRefBridge(
     getWorkflowMetadataSnapshot: () => {
       return clonePublicValue(runtime.getWorkflowMetadataSnapshot());
     },
+    queryScopes: (filter) => {
+      return clonePublicValue(runtime.queryScopes(filter));
+    },
+    findScopesAt: (position, options) => {
+      return clonePublicValue(runtime.findScopesAt(position, options));
+    },
+    findScopesIntersecting: (range, options) => {
+      return clonePublicValue(runtime.findScopesIntersecting(range, options));
+    },
+    findFirstText: (query, opts) => {
+      const hits = findTextMatchesForRuntime(runtime, query, opts);
+      return hits.length > 0 ? (hits[0] ?? null) : null;
+    },
+    findAllText: (query, opts) => {
+      return findTextMatchesForRuntime(runtime, query, opts);
+    },
+    selectFirstText: (query, opts) => {
+      const hits = findTextMatchesForRuntime(runtime, query, opts);
+      if (hits.length === 0) return false;
+      applyRuntimeSelection(runtime, createSelectionFromAnchor(hits[0]!));
+      return true;
+    },
+    selectAllText: (query, opts) => {
+      const hits = findTextMatchesForRuntime(runtime, query, opts);
+      if (hits.length === 0) return 0;
+      applyRuntimeSelection(runtime, createSelectionFromAnchor(hits[0]!));
+      return hits.length;
+    },
     // P17 — metadata persistence toggle + convert methods.
     setMetadataPersistenceMode: (mode) => {
       if (mode === "external" && !(options?.resolverRef?.current ?? null)) {
@@ -1976,6 +2004,34 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         getWorkflowMetadataSnapshot: () => {
           return clonePublicValue(activeRuntime.getWorkflowMetadataSnapshot());
         },
+        queryScopes: (filter) => {
+          return clonePublicValue(activeRuntime.queryScopes(filter));
+        },
+        findScopesAt: (position, options) => {
+          return clonePublicValue(activeRuntime.findScopesAt(position, options));
+        },
+        findScopesIntersecting: (range, options) => {
+          return clonePublicValue(activeRuntime.findScopesIntersecting(range, options));
+        },
+        findFirstText: (query, opts) => {
+          const hits = findTextMatchesForRuntime(activeRuntime, query, opts);
+          return hits.length > 0 ? (hits[0] ?? null) : null;
+        },
+        findAllText: (query, opts) => {
+          return findTextMatchesForRuntime(activeRuntime, query, opts);
+        },
+        selectFirstText: (query, opts) => {
+          const hits = findTextMatchesForRuntime(activeRuntime, query, opts);
+          if (hits.length === 0) return false;
+          applyRuntimeSelection(activeRuntime, createSelectionFromAnchor(hits[0]!));
+          return true;
+        },
+        selectAllText: (query, opts) => {
+          const hits = findTextMatchesForRuntime(activeRuntime, query, opts);
+          if (hits.length === 0) return 0;
+          applyRuntimeSelection(activeRuntime, createSelectionFromAnchor(hits[0]!));
+          return hits.length;
+        },
         // P17 — metadata persistence toggle + convert methods.
         setMetadataPersistenceMode: (mode) => {
           if (mode === "external" && scopeMetadataResolverRef.current === null) {
@@ -5056,6 +5112,20 @@ function clonePublicValue<T>(value: T): T {
   return structuredClone(value);
 }
 
+function findTextMatchesForRuntime(
+  runtime: WordReviewEditorRuntime,
+  query: string,
+  options: SearchOptions | undefined,
+): EditorAnchorProjection[] {
+  const snapshot = runtime.getRenderSnapshot();
+  return findTextMatches(
+    runtime.getSessionState().canonicalDocument,
+    snapshot.selection,
+    query,
+    options ?? {},
+  );
+}
+
 /**
  * Open the correct header/footer story for a specific page.  The page's
  * resolved `stories.header` / `stories.footer` already carries the

package/src/ui/editor-runtime-boundary.ts

@@ -1154,6 +1154,9 @@ function createLoadingRuntimeBridge(input: {
       definitions: [],
       entries: [],
     }),
+    queryScopes: () => [],
+    findScopesAt: () => [],
+    findScopesIntersecting: () => [],
     setHostAnnotationOverlay: () => undefined,
     clearHostAnnotationOverlay: () => undefined,
     getHostAnnotationSnapshot: () => ({

package/src/ui-tailwind/chrome-overlay/tw-chrome-overlay.tsx

@@ -28,6 +28,7 @@ import { TwScopeCardLayer } from "./tw-scope-card-layer";
 import { TwPageStackOverlayLayer } from "./tw-page-stack-overlay-layer";
 import { TwPageStackChromeLayer, type PmPortalView } from "../page-stack/tw-page-stack-chrome-layer";
 import { TwTableGripLayer } from "../chrome/tw-table-grip-layer";
+import { TwObjectSelectionOverlay } from "./tw-object-selection-overlay";
 
 export interface TwChromeOverlayProps {
   /** Layout facet the overlay layers read from. */
@@ -93,6 +94,16 @@ export interface TwChromeOverlayProps {
   /** Optional extra children (e.g., future comment balloon layer). */
   children?: React.ReactNode;
 
+  // Object selection overlay (N6) ----------------------------------------
+  /** R.3 — grabbed image/shape id, or null. When set, the selection overlay renders. */
+  grabbedObjectId?: string | null;
+  /** Document `from` offset of the grabbed segment (for anchor-index lookup). */
+  grabbedObjectFromOffset?: number | null;
+  /** Document `to` offset of the grabbed segment. */
+  grabbedObjectToOffset?: number | null;
+  /** Called when the user clicks outside the selection box to deselect. */
+  onDeselectObject?: () => void;
+
   // Table grip props (P6) -----------------------------------------------
   /** Active table context — when present, column/row resize grips are shown. */
   tableContext?: TableStructureContextSnapshot | null;
@@ -187,6 +198,10 @@ export const TwChromeOverlay: React.FC<TwChromeOverlayProps> = ({
   scopeCardScopeTagEditor,
   "data-testid": testId,
   children,
+  grabbedObjectId,
+  grabbedObjectFromOffset,
+  grabbedObjectToOffset,
+  onDeselectObject,
   tableContext,
   onSetColumnWidth,
   onSetRowHeight,
@@ -251,6 +266,14 @@ export const TwChromeOverlay: React.FC<TwChromeOverlayProps> = ({
         onSetColumnWidth={onSetColumnWidth}
         onSetRowHeight={onSetRowHeight}
       />
+      <TwObjectSelectionOverlay
+        grabbedObjectId={grabbedObjectId ?? null}
+        grabbedObjectFromOffset={grabbedObjectFromOffset ?? null}
+        grabbedObjectToOffset={grabbedObjectToOffset ?? null}
+        facet={facet}
+        space={space}
+        onDeselect={onDeselectObject}
+      />
       {children}
     </div>
   );

package/src/ui-tailwind/chrome-overlay/tw-object-selection-overlay.tsx

@@ -0,0 +1,157 @@
+/**
+ * Lane 6d — N6 P11.1–P11.5: object selection chrome overlay.
+ *
+ * Renders a selection box with 8 resize handles and a rotate grip around the
+ * grabbed image or shape.  Purely visual chrome — no resize/rotate mutations
+ * in this slice; handle interaction is deferred to the follow-up N6.b slice.
+ *
+ * Positioning: uses `RenderAnchorIndex.byRuntimeOffset(from)` + `bySelection`
+ * to compute the object rect in overlay-coordinate space, then paints over it.
+ *
+ * Dismissal: clicking outside the overlay calls `onDeselect()` which routes
+ * to `runtime.deselectObject()` in the workspace.
+ *
+ * v1 scope:
+ *   - rect, ellipse, roundRect shapes and inline/floating images.
+ *   - Resize handles are visual only (pointer-events-none on each handle).
+ *   - Rotate grip is visual only.
+ *   - Anchor drag indicator omitted until N6.b.
+ */
+
+import * as React from "react";
+import { useEffect, useRef } from "react";
+import type { WordReviewEditorLayoutFacet } from "../../api/public-types";
+import type { OverlayCoordinateSpace } from "./chrome-overlay-projector";
+import { projectRectToOverlay } from "./chrome-overlay-projector";
+
+/** The 8 corner/edge handle positions. */
+const HANDLE_POSITIONS = [
+  "nw", "n", "ne",
+  "w",        "e",
+  "sw", "s", "se",
+] as const;
+type HandlePosition = typeof HANDLE_POSITIONS[number];
+
+const CURSOR_MAP: Record<HandlePosition, string> = {
+  nw: "nw-resize", n: "n-resize", ne: "ne-resize",
+  w: "w-resize",               e: "e-resize",
+  sw: "sw-resize", s: "s-resize", se: "se-resize",
+};
+
+export interface TwObjectSelectionOverlayProps {
+  /** Stable id of the grabbed image/shape (mediaId or shapeId), or null. */
+  grabbedObjectId: string | null;
+  /** Document offset (`from`) of the grabbed object's inline segment. Null when no object grabbed. */
+  grabbedObjectFromOffset: number | null;
+  /** Document offset (`to`) of the grabbed object's inline segment. Null when no object grabbed. */
+  grabbedObjectToOffset: number | null;
+  /** Layout facet for render-frame + anchor-index access. */
+  facet: WordReviewEditorLayoutFacet;
+  /** Optional overlay coordinate-space override. */
+  space?: OverlayCoordinateSpace;
+  /** Called when the user clicks outside the selection box. */
+  onDeselect?: () => void;
+}
+
+export function TwObjectSelectionOverlay({
+  grabbedObjectId,
+  grabbedObjectFromOffset,
+  grabbedObjectToOffset,
+  facet,
+  space,
+  onDeselect,
+}: TwObjectSelectionOverlayProps) {
+  const overlayRef = useRef<HTMLDivElement>(null);
+
+  // Click-outside to deselect.
+  useEffect(() => {
+    if (!grabbedObjectId || !onDeselect) return;
+    function handlePointerDown(e: PointerEvent) {
+      if (overlayRef.current && !overlayRef.current.contains(e.target as Node)) {
+        onDeselect!();
+      }
+    }
+    document.addEventListener("pointerdown", handlePointerDown, { capture: true });
+    return () => document.removeEventListener("pointerdown", handlePointerDown, { capture: true });
+  }, [grabbedObjectId, onDeselect]);
+
+  if (!grabbedObjectId || grabbedObjectFromOffset == null) return null;
+
+  const frame = typeof facet.getRenderFrame === "function" ? facet.getRenderFrame() : null;
+  if (!frame) return null;
+
+  const rawRect = grabbedObjectToOffset != null
+    ? frame.anchorIndex.bySelection(grabbedObjectFromOffset, grabbedObjectToOffset)
+    : frame.anchorIndex.byRuntimeOffset(grabbedObjectFromOffset);
+  if (!rawRect) return null;
+
+  const rect = projectRectToOverlay(rawRect, space);
+
+  const boxStyle: React.CSSProperties = {
+    position: "absolute",
+    left: rect.left,
+    top: rect.top,
+    width: rect.width,
+    height: rect.height,
+    outline: "2px solid var(--color-accent-primary)",
+    boxSizing: "border-box",
+    pointerEvents: "auto",
+  };
+
+  return (
+    <div
+      ref={overlayRef}
+      style={boxStyle}
+      data-object-selection=""
+      data-object-id={grabbedObjectId}
+      aria-label="Selected object"
+    >
+      {HANDLE_POSITIONS.map((pos) => (
+        <ObjectHandle key={pos} position={pos} />
+      ))}
+      <RotateGrip />
+    </div>
+  );
+}
+
+function ObjectHandle({ position }: { position: HandlePosition }) {
+  const HANDLE_PX = 8;
+  const half = HANDLE_PX / 2;
+  const pos = position;
+
+  const style: React.CSSProperties = {
+    position: "absolute",
+    width: HANDLE_PX,
+    height: HANDLE_PX,
+    background: "white",
+    border: "1.5px solid var(--color-accent-primary)",
+    borderRadius: 1,
+    boxSizing: "border-box",
+    cursor: CURSOR_MAP[pos],
+    // Visual only in v1 — pointer events disabled so clicks fall through to
+    // the click-outside listener which deselectObjects.
+    pointerEvents: "none",
+    ...(pos.includes("w") ? { left: -half } : pos.includes("e") ? { right: -half } : { left: "50%", transform: "translateX(-50%)" }),
+    ...(pos.includes("n") ? { top: -half } : pos.includes("s") ? { bottom: -half } : { top: "50%", transform: `${pos === "w" || pos === "e" ? "translateY(-50%)" : "translateX(-50%) translateY(-50%)"}` }),
+  };
+
+  return <div style={style} data-handle={pos} aria-hidden="true" />;
+}
+
+function RotateGrip() {
+  const style: React.CSSProperties = {
+    position: "absolute",
+    width: 10,
+    height: 10,
+    borderRadius: "50%",
+    background: "white",
+    border: "1.5px solid var(--color-accent-primary)",
+    top: -24,
+    left: "50%",
+    transform: "translateX(-50%)",
+    cursor: "grab",
+    pointerEvents: "none",
+    boxSizing: "border-box",
+  };
+  return <div style={style} data-handle="rotate" aria-hidden="true" />;
+}

package/src/ui-tailwind/editor-surface/pm-schema.ts

@@ -465,6 +465,10 @@ export const editorSchema = new Schema({
         wrapMode: { default: null },
         distMargins: { default: null },
         positionH: { default: null },
+        // Lane 6d N11.b — CSS filter effects (soft-edge, outer shadow, glow).
+        softEdgeRadius: { default: null },
+        outerShadow: { default: null },
+        glow: { default: null },
       },
       toDOM(node) {
         const isMissing = node.attrs.state === "missing";
@@ -496,6 +500,27 @@ export const editorSchema = new Schema({
               `inset(${(srcRect.top / SRCRECT_UNITS_PER_PERCENT).toFixed(3)}% ${(srcRect.right / SRCRECT_UNITS_PER_PERCENT).toFixed(3)}% ${(srcRect.bottom / SRCRECT_UNITS_PER_PERCENT).toFixed(3)}% ${(srcRect.left / SRCRECT_UNITS_PER_PERCENT).toFixed(3)}%)`,
             );
           }
+          // N11.b filter effects → CSS filter on the img element.
+          const softEdgeRadius = node.attrs.softEdgeRadius as number | null;
+          const outerShadow = node.attrs.outerShadow as {
+            blurRad: number; dist: number; dir: number; color: string;
+          } | null;
+          const glow = node.attrs.glow as { radius: number; color: string } | null;
+          const filterParts: string[] = [];
+          if (softEdgeRadius) {
+            filterParts.push(`blur(${(softEdgeRadius / EMU_PER_PX).toFixed(2)}px)`);
+          }
+          if (glow) {
+            filterParts.push(`drop-shadow(0 0 ${(glow.radius / EMU_PER_PX).toFixed(2)}px #${glow.color})`);
+          }
+          if (outerShadow) {
+            const blurPx = (outerShadow.blurRad / EMU_PER_PX).toFixed(2);
+            const distPx = outerShadow.dist / EMU_PER_PX;
+            const dirRad = (outerShadow.dir / ROTATION_UNITS_PER_DEGREE) * (Math.PI / 180);
+            const dx = (distPx * Math.cos(dirRad)).toFixed(2);
+            const dy = (distPx * Math.sin(dirRad)).toFixed(2);
+            filterParts.push(`drop-shadow(${dx}px ${dy}px ${blurPx}px #${outerShadow.color})`);
+          }
           // N9 float-wrap → CSS float + shape-outside on the wrapper span.
           const wrapMode = node.attrs.wrapMode as string | null;
           const positionH = node.attrs.positionH as { align?: string } | null;
@@ -527,6 +552,7 @@ export const editorSchema = new Schema({
             heightPx ? `height:${heightPx}px` : "",
             transformParts.length > 0 ? `transform:${transformParts.join(" ")}` : "",
             clipParts.length > 0 ? `clip-path:${clipParts[0]}` : "",
+            filterParts.length > 0 ? `filter:${filterParts.join(" ")}` : "",
           ].filter(Boolean).join(";");
           const wrapperStyle = wrapperStyleParts.join(";");
           const wrapperAttrs: Record<string, string> = {

package/src/ui-tailwind/editor-surface/pm-state-from-snapshot.ts

@@ -464,6 +464,10 @@ function buildInlineContent(
           wrapMode: segment.anchor?.wrapMode ?? null,
           distMargins: segment.anchor?.distMargins ?? null,
           positionH: segment.anchor?.positionH ?? null,
+          // Lane 6d N11.b — filter effects.
+          softEdgeRadius: segment.pictureEffects?.softEdgeRadius ?? null,
+          outerShadow: segment.pictureEffects?.outerShadow ?? null,
+          glow: segment.pictureEffects?.glow ?? null,
         }),
       ];
       }

package/src/ui-tailwind/tw-review-workspace.tsx

@@ -198,6 +198,8 @@ export interface TwReviewWorkspaceProps {
   selectionContextAnalytics?: RuntimeContextAnalyticsSnapshot | null;
   currentScopeContextAnalytics?: RuntimeContextAnalyticsSnapshot | null;
   commands: EditorCommandBag;
+  /** N6 — release the grabbed image/shape. Wired to `runtime.deselectObject()` by the host. */
+  onDeselectObject?: () => void;
   activeSelectionTool?: ActiveSelectionToolModel | null;
   selectionToolAnchor?: SelectionToolAnchor | null;
   documentNavigation?: DocumentNavigationSnapshot;
@@ -680,6 +682,23 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
   // above bumps `renderFrameRevision` on the same kinds; including it
   // in the dependency list re-runs this memo without a separate
   // subscription.
+  // N6 — resolve grabbed-object segment offsets from the surface so the
+  // selection overlay can query the anchor index without a full surface walk.
+  const grabbedSegmentOffsets = useMemo(() => {
+    const objectId = snapshot.grabbedObjectId ?? null;
+    if (!objectId || !snapshot.surface) return null;
+    for (const block of snapshot.surface.blocks) {
+      if (!("segments" in block)) continue;
+      for (const seg of (block as { segments?: unknown[] }).segments ?? []) {
+        const s = seg as { kind?: string; mediaId?: string; from?: number; to?: number };
+        if ((s.kind === "image" || s.kind === "shape") && s.mediaId === objectId && s.from != null) {
+          return { from: s.from, to: s.to ?? s.from + 1 };
+        }
+      }
+    }
+    return null;
+  }, [snapshot.grabbedObjectId, snapshot.surface]);
+
   const statusBarPageFacts = useMemo(() => {
     const facet = props.layoutFacet;
     if (!facet) {
@@ -1662,6 +1681,10 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
                         {props.layoutFacet ? (
                           <TwChromeOverlay
                             facet={props.layoutFacet}
+                            grabbedObjectId={snapshot.grabbedObjectId ?? null}
+                            grabbedObjectFromOffset={grabbedSegmentOffsets?.from ?? null}
+                            grabbedObjectToOffset={grabbedSegmentOffsets?.to ?? null}
+                            onDeselectObject={props.onDeselectObject}
                             tableContext={props.tableContext}
                             onSetColumnWidth={props.onSetColumnWidth}
                             onSetRowHeight={props.onSetRowHeight}