@elytracms/studio 0.0.1

package/dist/lib/data/sample-capture.d.ts

@@ -0,0 +1,30 @@
+import type { DataSource } from '@elytracms/data-binding';
+import type { JsonValue } from '@elytracms/project-graph';
+import type { CollectionDef } from '@elytracms/cms-core';
+/**
+ * Data-source sample capture (EC-083/EC-166/EC-167). The hosted builder is
+ * separate from the site it exports: actually performing a REST fetch / external
+ * query happens behind the project-owned adapters in the deployed site, NOT here.
+ * So the studio captures a sample ONLY when it can do so honestly — it never
+ * fabricates data (Oli, 2026-06-19; cf. backend-mode's "never silently swap in
+ * in-memory storage", and the v1 "static props, bindings parked" direction):
+ *
+ * - a provider-backed source runs its registered provider (real project code);
+ * - a CMS source replays its stored query over the live content session (Convex
+ *   mode — EC-177 gap 1), so section/template previews show what delivery serves;
+ * - anything else — an external source with no in-studio data path — returns
+ *   `undefined`. The source then carries no sample, and the binding UI shows an
+ *   honest "no sample yet" state instead of inventing rows that aren't there.
+ */
+export declare function captureSourceSample(source: DataSource): JsonValue | undefined;
+/**
+ * A live CMS data source for one config-driven collection (EC-192). The binding
+ * and condition pickers enumerate `data.sources`; deriving one source per
+ * configured content collection — the same set the CMS uses
+ * (`resolveDeploymentCollections`) — means what an editor can bind matches what
+ * actually exists. The sample is captured by replaying the collection's list
+ * query through the canonical content engine, so when a content session is
+ * configured (Convex mode) the inferred field tokens are the collection's real
+ * fields; with no session the source is listed but carries no sample.
+ */
+export declare function cmsSourceForCollection(collection: CollectionDef): DataSource;

package/dist/lib/data/sample-capture.js

@@ -0,0 +1,70 @@
+import { captureSample } from '@elytracms/data-binding';
+import { humanizeName } from '../utils';
+import { listQueryOfConfig } from '../bindings/section-bindings';
+import { getCollectionDocument, hasContentSession, playgroundCollection, runCollectionListQuery, } from './collection-content';
+import { providerIdOfSource, providerPayload } from './providers';
+/**
+ * Data-source sample capture (EC-083/EC-166/EC-167). The hosted builder is
+ * separate from the site it exports: actually performing a REST fetch / external
+ * query happens behind the project-owned adapters in the deployed site, NOT here.
+ * So the studio captures a sample ONLY when it can do so honestly — it never
+ * fabricates data (Oli, 2026-06-19; cf. backend-mode's "never silently swap in
+ * in-memory storage", and the v1 "static props, bindings parked" direction):
+ *
+ * - a provider-backed source runs its registered provider (real project code);
+ * - a CMS source replays its stored query over the live content session (Convex
+ *   mode — EC-177 gap 1), so section/template previews show what delivery serves;
+ * - anything else — an external source with no in-studio data path — returns
+ *   `undefined`. The source then carries no sample, and the binding UI shows an
+ *   honest "no sample yet" state instead of inventing rows that aren't there.
+ */
+export function captureSourceSample(source) {
+    const providerId = providerIdOfSource(source);
+    if (providerId !== undefined) {
+        return providerPayload(providerId, source.kind === 'convex' ? source.config.args : undefined);
+    }
+    if (source.kind === 'cms') {
+        return cmsDeliverySample(source.config);
+    }
+    return undefined;
+}
+/**
+ * A live CMS data source for one config-driven collection (EC-192). The binding
+ * and condition pickers enumerate `data.sources`; deriving one source per
+ * configured content collection — the same set the CMS uses
+ * (`resolveDeploymentCollections`) — means what an editor can bind matches what
+ * actually exists. The sample is captured by replaying the collection's list
+ * query through the canonical content engine, so when a content session is
+ * configured (Convex mode) the inferred field tokens are the collection's real
+ * fields; with no session the source is listed but carries no sample.
+ */
+export function cmsSourceForCollection(collection) {
+    const source = {
+        kind: 'cms',
+        id: `cms.${collection.id}`,
+        label: humanizeName(collection.id),
+        config: { collectionId: collection.id, filter: {}, limit: 20 },
+    };
+    const sample = captureSourceSample(source);
+    return sample !== undefined ? captureSample(source, sample) : source;
+}
+/**
+ * Replay a CMS source's stored query over the configured content session, in
+ * delivery shape (EC-166). Returns `undefined` when no session serves the
+ * collection (playground / no backend) — the caller then leaves the source
+ * sample-less rather than fabricating one. A query the engine rejects — or one
+ * matching nothing — yields an empty list / `null`, never a crash.
+ */
+function cmsDeliverySample(config) {
+    if (!hasContentSession())
+        return undefined;
+    if (playgroundCollection(config.collectionId) === undefined)
+        return undefined;
+    if (config.documentId !== undefined) {
+        const result = getCollectionDocument(config.collectionId, config.documentId);
+        return result.document ?? null;
+    }
+    const result = runCollectionListQuery(config.collectionId, listQueryOfConfig(config));
+    return result.ok ? result.documents : [];
+}
+//# sourceMappingURL=sample-capture.js.map

package/dist/lib/data/sample-capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-capture.js","sourceRoot":"","sources":["../../../src/lib/data/sample-capture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAIvD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAEhE,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAEjE;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAkB;IACpD,MAAM,UAAU,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAA;IAC7C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;IAC/F,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QAC1B,OAAO,iBAAiB,CAAC,MAAM,CAAC,MAAwB,CAAC,CAAA;IAC3D,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CAAC,UAAyB;IAC9D,MAAM,MAAM,GAAe;QACzB,IAAI,EAAE,KAAK;QACX,EAAE,EAAE,OAAO,UAAU,CAAC,EAAE,EAAE;QAC1B,KAAK,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,CAAC;QAClC,MAAM,EAAE,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;KAC/D,CAAA;IACD,MAAM,MAAM,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAA;IAC1C,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAA;AACtE,CAAC;AAED;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,MAAsB;IAC/C,IAAI,CAAC,iBAAiB,EAAE;QAAE,OAAO,SAAS,CAAA;IAC1C,IAAI,oBAAoB,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,SAAS;QAAE,OAAO,SAAS,CAAA;IAC7E,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,qBAAqB,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;QAC5E,OAAQ,MAAM,CAAC,QAAiC,IAAI,IAAI,CAAA;IAC1D,CAAC;IACD,MAAM,MAAM,GAAG,sBAAsB,CAAC,MAAM,CAAC,YAAY,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAA;IACrF,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,CAAE,MAAM,CAAC,SAAkC,CAAC,CAAC,CAAC,EAAE,CAAA;AACpE,CAAC"}

package/dist/lib/data/sources-store.d.ts

@@ -0,0 +1,42 @@
+import type { DataSource } from '@elytracms/data-binding';
+import type { CmsDocument, CollectionDef } from '@elytracms/cms-core';
+import type { OperationResult, OperationsClient } from '../operations';
+/**
+ * Data-source persistence for the Builder's data layer (LIVE-mode gap fix).
+ *
+ * EC-166/EC-167 made the builder provision per-section (`cms.section.<nodeId>`)
+ * and per-template (`cms.template.<pageId>`) CMS sources, but only as session
+ * state — the live delivery chain (`convex/delivery.ts` →
+ * `apps/example-site/lib/live-content.ts`) had nothing to carry. Following the
+ * EC-170 routing-store / EC-169 views-store pattern, sources persist as
+ * documents in ONE system collection, one document per source, and every
+ * mutation goes through the *existing* `@elytracms/operations` commands
+ * (`schema.upsertCollection`, `documents.upsert`, `documents.delete`) — no new
+ * operations surface, no direct repository access.
+ *
+ * The record round-trips the FULL canonical `DataSource` shape (including the
+ * captured `sample` + inferred `schema` envelope and the cms config's `sort`):
+ * `@elytracms/data-binding`'s `dataSourceSchema` is the source of truth, applied
+ * on both write and read, so a malformed stored record is dropped on load —
+ * never a crash, never a half-parsed source.
+ */
+export declare const DATA_SOURCES_COLLECTION = "cms-data-sources";
+/** System collection holding one document per persisted {@link DataSource}. */
+export declare const dataSourcesCollectionDef: CollectionDef;
+export declare function sourceToDocument(source: DataSource): CmsDocument;
+export declare function documentToSource(document: CmsDocument): DataSource | undefined;
+/** Load every persisted data source of a project (malformed records dropped). */
+export declare function loadDataSources(operations: OperationsClient, projectId: string): Promise<OperationResult<DataSource[]>>;
+/**
+ * Make sure the system collection exists in the project's CMS schema so
+ * `documents.upsert` accepts source documents. Idempotent.
+ */
+export declare function ensureDataSourcesCollection(_operations: OperationsClient, _projectId: string): Promise<OperationResult<void>>;
+/** Create or update a persisted data source (operations command). */
+export declare function saveDataSource(operations: OperationsClient, projectId: string, source: DataSource): Promise<OperationResult<void>>;
+/**
+ * Delete a persisted data source. A source that was never persisted (pure
+ * session state, e.g. a seed) deletes as a no-op — `not-found` is success
+ * here, since the goal state ("no persisted record") already holds.
+ */
+export declare function deleteDataSource(operations: OperationsClient, projectId: string, sourceId: string): Promise<OperationResult<void>>;

package/dist/lib/data/sources-store.js

@@ -0,0 +1,120 @@
+import { dataSourceSchema } from '@elytracms/data-binding';
+/**
+ * Data-source persistence for the Builder's data layer (LIVE-mode gap fix).
+ *
+ * EC-166/EC-167 made the builder provision per-section (`cms.section.<nodeId>`)
+ * and per-template (`cms.template.<pageId>`) CMS sources, but only as session
+ * state — the live delivery chain (`convex/delivery.ts` →
+ * `apps/example-site/lib/live-content.ts`) had nothing to carry. Following the
+ * EC-170 routing-store / EC-169 views-store pattern, sources persist as
+ * documents in ONE system collection, one document per source, and every
+ * mutation goes through the *existing* `@elytracms/operations` commands
+ * (`schema.upsertCollection`, `documents.upsert`, `documents.delete`) — no new
+ * operations surface, no direct repository access.
+ *
+ * The record round-trips the FULL canonical `DataSource` shape (including the
+ * captured `sample` + inferred `schema` envelope and the cms config's `sort`):
+ * `@elytracms/data-binding`'s `dataSourceSchema` is the source of truth, applied
+ * on both write and read, so a malformed stored record is dropped on load —
+ * never a crash, never a half-parsed source.
+ */
+export const DATA_SOURCES_COLLECTION = 'cms-data-sources';
+/** System collection holding one document per persisted {@link DataSource}. */
+export const dataSourcesCollectionDef = {
+    id: DATA_SOURCES_COLLECTION,
+    kind: 'document',
+    titleField: 'label',
+    form: {
+        label: 'Data sources',
+        labelSingular: 'Data source',
+        description: "System collection managed by the Builder's data layer.",
+    },
+    fields: [
+        { name: 'label', type: 'text', validation: { required: true } },
+        /** The source kind (`rest` | `cms` | `convex`), denormalized for table views. */
+        { name: 'kind', type: 'text', validation: { required: true } },
+        /** The FULL canonical DataSource, JSON-serialized (validated by Zod on read). */
+        { name: 'config', type: 'text', validation: { required: true } },
+    ],
+};
+// ---- Source ⇄ document mapping ----
+export function sourceToDocument(source) {
+    const parsed = dataSourceSchema.parse(source);
+    return {
+        collection: DATA_SOURCES_COLLECTION,
+        id: parsed.id,
+        values: {
+            label: parsed.label,
+            kind: parsed.kind,
+            config: JSON.stringify(parsed),
+        },
+    };
+}
+export function documentToSource(document) {
+    const raw = document.values.config;
+    let value;
+    try {
+        value = typeof raw === 'string' ? JSON.parse(raw) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const parsed = dataSourceSchema.safeParse(value);
+    if (!parsed.success)
+        return undefined;
+    // The document id is the source id — a record whose payload disagrees with
+    // its own key is malformed and never loads.
+    return parsed.data.id === document.id ? parsed.data : undefined;
+}
+// ---- Reads & writes through @elytracms/operations ----
+/** Load every persisted data source of a project (malformed records dropped). */
+export async function loadDataSources(operations, projectId) {
+    const result = await operations.documents.list({
+        projectId,
+        collection: DATA_SOURCES_COLLECTION,
+    });
+    if (!result.ok)
+        return result;
+    return {
+        ok: true,
+        value: result.value
+            .map((record) => documentToSource(record.document))
+            .filter((source) => source !== undefined),
+    };
+}
+/**
+ * Make sure the system collection exists in the project's CMS schema so
+ * `documents.upsert` accepts source documents. Idempotent.
+ */
+export async function ensureDataSourcesCollection(_operations, _projectId) {
+    // No-op (EC-183, AD-11): the data-sources system collection is config-owned and
+    // the backend stores documents without a schema-membership check — nothing to
+    // register. `dataSourcesCollectionDef` remains the canonical document shape.
+    return { ok: true, value: undefined };
+}
+/** Create or update a persisted data source (operations command). */
+export async function saveDataSource(operations, projectId, source) {
+    const ensured = await ensureDataSourcesCollection(operations, projectId);
+    if (!ensured.ok)
+        return ensured;
+    const result = await operations.documents.upsert({
+        projectId,
+        document: sourceToDocument(source),
+    });
+    return result.ok ? { ok: true, value: undefined } : result;
+}
+/**
+ * Delete a persisted data source. A source that was never persisted (pure
+ * session state, e.g. a seed) deletes as a no-op — `not-found` is success
+ * here, since the goal state ("no persisted record") already holds.
+ */
+export async function deleteDataSource(operations, projectId, sourceId) {
+    const result = await operations.documents.delete({
+        projectId,
+        ref: { collection: DATA_SOURCES_COLLECTION, id: sourceId },
+    });
+    if (!result.ok && result.error.code === 'not-found')
+        return { ok: true, value: undefined };
+    return result.ok ? { ok: true, value: undefined } : result;
+}
+//# sourceMappingURL=sources-store.js.map

package/dist/lib/data/sources-store.js.map

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

package/dist/lib/dnd/drop-rules.d.ts

@@ -0,0 +1,219 @@
+import type { ComponentNode, GridContainerOptions, InsertTarget } from '@elytracms/project-graph';
+/**
+ * Drag & drop eligibility rules (EC-160 + EC-162, vision §3.1) — pure
+ * graph-level functions with **no DOM or UI dependencies**. The canvas and the
+ * page tree both resolve drops through `resolveDrop`, so the two surfaces can
+ * never disagree about what a manifest slot allow-list permits, which children
+ * a component accepts, or whether a move would create a cycle.
+ *
+ * The drop-zone model is position-based: `into` a slot, `before`/`after` a
+ * sibling along the parent's flow axis, and the EC-162 gesture positions
+ * `left`/`right` — dropping *beside* an element wraps both in a two-column
+ * `Grid` container (see `applyWrap`).
+ */
+/**
+ * The manifest slice the rules evaluate. Structural (not the full
+ * `ComponentManifest`) so tests and future callers can feed minimal lookups.
+ */
+export interface SlotRule {
+    name: string;
+    /** Restrict which component ids may be inserted (omit to allow any). */
+    allow?: string[];
+}
+export interface ManifestRules {
+    slots: SlotRule[];
+}
+/** Resolve a component id to its manifest slot rules (undefined = unknown component). */
+export type ManifestLookup = (componentId: string) => ManifestRules | undefined;
+/** What is being dragged. */
+export type DragSubject = 
+/** An existing node of the current page — a completed drop is a `move`. */
+{
+    kind: 'node';
+    nodeId: string;
+    componentId: string;
+}
+/** A new subtree (blocks-panel tile) — a completed drop is an `insert`. */
+ | {
+    kind: 'component';
+    componentId: string;
+};
+/**
+ * Where, relative to a reference node, the drop would land. `into`, `before`
+ * and `after` are the EC-160 positions; `left`/`right` are the EC-162 gesture
+ * positions — "beside" the reference, wrapping both elements in a two-column
+ * `Grid` container.
+ */
+export type DropPosition = 'into' | 'before' | 'after' | 'left' | 'right';
+/** The side of the reference an EC-162 wrap gesture drops on. */
+export type WrapSide = 'left' | 'right';
+export interface DropLocation {
+    /** The reference node id (the hovered node/row). */
+    nodeId: string;
+    position: DropPosition;
+}
+export type DropRejectionCode = 
+/** The reference node does not exist in the tree. */
+'missing-target'
+/** `into` on a component that declares no insertable slot. */
+ | 'no-slot'
+/** The target slot's manifest allow-list rejects the dragged component. */
+ | 'not-allowed'
+/** Moving a node into itself or its own subtree (cycle). */
+ | 'own-subtree'
+/** The page root cannot be moved, and nothing can drop beside it. */
+ | 'root'
+/** Structurally valid but changes nothing (dropping a node onto its own position). */
+ | 'no-op';
+export interface DropRejection {
+    eligible: false;
+    code: DropRejectionCode;
+    reason: string;
+}
+/** An eligible drop: exactly one builder action (move, insert, or wrap) commits it. */
+export type DropPlan = {
+    eligible: true;
+    kind: 'move';
+    nodeId: string;
+    target: InsertTarget;
+} | {
+    eligible: true;
+    kind: 'insert';
+    target: InsertTarget;
+}
+/**
+ * EC-162 wrap gesture: the reference node and the dragged subject become the
+ * two columns of a new `Grid` container, created atomically (`applyWrap`).
+ * `nodeId` is present when the subject is an existing node (a move-wrap);
+ * absent for blocks-panel components (an insert-wrap via `buildNode`).
+ */
+ | {
+    eligible: true;
+    kind: 'wrap';
+    referenceId: string;
+    side: WrapSide;
+    nodeId?: string;
+};
+export type DropResolution = DropPlan | DropRejection;
+/**
+ * The slot an `into` drop inserts into: the default `children` slot when
+ * declared, else the first authored slot that is not the layout `outlet`.
+ * Mirrors the shell's insert-context resolution so click-insert and
+ * drag-insert land in the same place.
+ */
+export declare function primaryInsertSlot(manifest: ManifestRules | undefined): SlotRule | undefined;
+/** True when a component can receive `into` drops at all (declares an insertable slot). */
+export declare function canNestInto(getManifest: ManifestLookup, componentId: string): boolean;
+/** True when a slot's allow-list (if any) permits the component id. */
+export declare function slotAllows(slot: SlotRule | undefined, componentId: string): boolean;
+/**
+ * Resolve a prospective drop into either an executable plan (one `move` or
+ * `insert` builder action → one operations command → one undo step) or a
+ * structured rejection the UI shows *during* the drag. Pure: same inputs,
+ * same answer, on both surfaces.
+ */
+export declare function resolveDrop(args: {
+    root: ComponentNode;
+    getManifest: ManifestLookup;
+    subject: DragSubject;
+    location: DropLocation;
+}): DropResolution;
+/**
+ * The container a "drop beside" gesture creates. Canonical choice (EC-161
+ * semantics): a `Grid` with two columns, **not** a horizontal `Stack` —
+ * EC-161 gives `Grid` the canonical column vocabulary (`columns` is a
+ * validated graph value the contextual inspector refines from 2 → n), while
+ * a horizontal Stack expresses flow order, not column tracks. The values
+ * mirror the Grid manifest defaults (`columns: 2`, `gap: '4'`), so the
+ * gesture's graph is exactly what composing the same layout manually would
+ * produce.
+ */
+export declare const WRAP_GRID_OPTIONS: GridContainerOptions;
+/** What lands beside the reference: an existing node (moved) or a built subtree (inserted). */
+export type WrapPartner = {
+    kind: 'node';
+    nodeId: string;
+} | {
+    kind: 'subtree';
+    node: ComponentNode;
+};
+export interface WrapResult {
+    root: ComponentNode;
+    /** The id of the created Grid container. */
+    containerId: string;
+}
+/**
+ * Execute a wrap plan as **one** structural edit: lift the partner out of the
+ * tree (when it is an existing node) and replace the reference with
+ * `gridContainerNode(containerId, WRAP_GRID_OPTIONS, [left, right])` in a
+ * single pass. The caller commits the result as one builder action → one
+ * operations command → one undo step; EC-161 normalization then runs on the
+ * *committed* tree, so the two-child container can never be observed (or
+ * persisted) in a half-built state. Returns `null` for structurally invalid
+ * input (missing nodes, root reference, reference inside the partner).
+ *
+ * Determinism (EC-162): the produced container subtree is exactly the
+ * `gridContainerNode` constructor output — identical to manual composition.
+ */
+export declare function applyWrap(args: {
+    root: ComponentNode;
+    referenceId: string;
+    side: WrapSide;
+    partner: WrapPartner;
+    containerId: string;
+}): WrapResult | null;
+/** The axis along which a container lays out its children. */
+export type FlowAxis = 'vertical' | 'horizontal';
+/**
+ * The flow axis of a container — the axis its children stack along, and
+ * therefore the hit-band axis for drops over those children (EC-162 ledger
+ * fix: bands follow the parent's flow direction, on both surfaces). Mirrors
+ * the renderer: a horizontal Stack flows horizontally; a Grid flows
+ * horizontally when it actually has ≥ 2 column tracks (an absent/invalid
+ * `columns` renders one column). Everything else is block flow (vertical).
+ */
+export declare function containerFlowAxis(node: ComponentNode | undefined): FlowAxis;
+/**
+ * Map a 2D pointer offset within a drop target's box onto a `DropPosition`
+ * (EC-162). `flow` is the flow axis of the target's *parent* — before/after
+ * bands run along it. On vertically flowing targets, narrow side bands on the
+ * cross axis produce `left`/`right` (the wrap-into-columns gesture, when
+ * `wrappable`); children of horizontal containers get left/right bands for
+ * plain reorder instead, so "beside" already means before/after there.
+ */
+export declare function dropPositionForPoint(args: {
+    /** Pointer offset across the target's width, 0..1. */
+    x: number;
+    /** Pointer offset across the target's height, 0..1. */
+    y: number;
+    /** Flow axis of the target's parent (the axis siblings stack along). */
+    flow: FlowAxis;
+    nestable: boolean;
+    edges: boolean;
+    /** Enable the wrap side-bands (the gesture surface opts in). */
+    wrappable?: boolean;
+}): DropPosition;
+/**
+ * Map a pointer offset within a drop target's box onto a `DropPosition`.
+ * `ratio` is the pointer's offset along the target's main axis, 0..1 — the
+ * caller picks the axis (the parent's flow axis; see `containerFlowAxis`).
+ *
+ * - nestable targets with siblings: edge quarters insert before/after, the
+ *   middle half nests into the slot
+ * - leaf targets: top/bottom halves insert before/after
+ * - targets without siblings (the root): always `into`
+ */
+export declare function dropPositionForPointer(args: {
+    ratio: number;
+    /** Whether `into` is structurally possible (target declares an insert slot). */
+    nestable: boolean;
+    /** Whether before/after exist (target has a parent slot). */
+    edges: boolean;
+}): DropPosition;
+/**
+ * The visual state a surface shows for the current resolution. `blocked` is
+ * the explicit rejection state (never a silent failed drop); `null` means show
+ * nothing (a no-op drop is inert, not an error).
+ */
+export type DropIndicator = DropPosition | 'blocked' | null;
+export declare function dropIndicatorFor(resolution: DropResolution, position: DropPosition): DropIndicator;