@elytracms/core 0.0.6

package/dist/operations/members.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import type { OperationsRuntime } from './core';
+/**
+ * Project-member management (EC-150, vision AD-7). Membership writes flow
+ * through the same chokepoint as every other mutation, so the role hook can
+ * enforce that only project `admin`s manage members — editors and viewers get
+ * structured denials, never UI-only gating.
+ */
+export declare const setMemberInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    userId: z.ZodString;
+    role: z.ZodEnum<{
+        admin: "admin";
+        editor: "editor";
+        viewer: "viewer";
+    }>;
+}, z.core.$strip>;
+export declare const removeMemberInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    userId: z.ZodString;
+}, z.core.$strip>;
+export declare const listMembersInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, z.core.$strip>;
+export declare const memberOperationDefinitions: {
+    readonly set: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+        userId: z.ZodString;
+        role: z.ZodEnum<{
+            admin: "admin";
+            editor: "editor";
+            viewer: "viewer";
+        }>;
+    }, z.core.$strip>, {
+        projectId: string;
+        userId: string;
+        role: "admin" | "editor" | "viewer";
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    readonly remove: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+        userId: z.ZodString;
+    }, z.core.$strip>, {
+        projectId: string;
+        userId: string;
+    }>;
+    readonly list: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+    }, z.core.$strip>, {
+        projectId: string;
+        userId: string;
+        role: "admin" | "editor" | "viewer";
+        createdAt: string;
+        updatedAt: string;
+    }[]>;
+};
+export declare function createMemberOperations(runtime: OperationsRuntime): {
+    set: (input: {
+        projectId: string;
+        userId: string;
+        role: "admin" | "editor" | "viewer";
+    }) => Promise<import("./core").OperationResult<{
+        projectId: string;
+        userId: string;
+        role: "admin" | "editor" | "viewer";
+        createdAt: string;
+        updatedAt: string;
+    }>>;
+    remove: (input: {
+        projectId: string;
+        userId: string;
+    }) => Promise<import("./core").OperationResult<{
+        projectId: string;
+        userId: string;
+    }>>;
+    list: (input: {
+        projectId: string;
+    }) => Promise<import("./core").OperationResult<{
+        projectId: string;
+        userId: string;
+        role: "admin" | "editor" | "viewer";
+        createdAt: string;
+        updatedAt: string;
+    }[]>>;
+};
+export type MemberOperations = ReturnType<typeof createMemberOperations>;

package/dist/operations/members.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { projectIdSchema } from '@elytracms/core/studio-core';
+import { projectRoleSchema } from '@elytracms/core/persistence';
+import { bindOperation, defineCommand, defineQuery } from './core';
+/**
+ * Project-member management (EC-150, vision AD-7). Membership writes flow
+ * through the same chokepoint as every other mutation, so the role hook can
+ * enforce that only project `admin`s manage members — editors and viewers get
+ * structured denials, never UI-only gating.
+ */
+export const setMemberInputSchema = z.object({
+    projectId: projectIdSchema,
+    userId: z.string().min(1),
+    role: projectRoleSchema,
+});
+export const removeMemberInputSchema = z.object({
+    projectId: projectIdSchema,
+    userId: z.string().min(1),
+});
+export const listMembersInputSchema = z.object({
+    projectId: projectIdSchema,
+});
+export const memberOperationDefinitions = {
+    set: defineCommand({
+        name: 'members.set',
+        domain: 'members',
+        description: 'Add a member to a project or change their role (admin/editor/viewer).',
+        input: setMemberInputSchema,
+        execute: (context, input) => context.adapter.members.setMember(input.projectId, input.userId, input.role),
+    }),
+    remove: defineCommand({
+        name: 'members.remove',
+        domain: 'members',
+        description: 'Remove a member from a project.',
+        input: removeMemberInputSchema,
+        execute: async (context, input) => {
+            await context.adapter.members.removeMember(input.projectId, input.userId);
+            return { projectId: input.projectId, userId: input.userId };
+        },
+    }),
+    list: defineQuery({
+        name: 'members.list',
+        domain: 'members',
+        description: 'List the members of a project with their roles.',
+        input: listMembersInputSchema,
+        execute: (context, input) => context.adapter.members.listMembers(input.projectId),
+    }),
+};
+export function createMemberOperations(runtime) {
+    return {
+        set: bindOperation(runtime, memberOperationDefinitions.set),
+        remove: bindOperation(runtime, memberOperationDefinitions.remove),
+        list: bindOperation(runtime, memberOperationDefinitions.list),
+    };
+}
+//# sourceMappingURL=members.js.map

package/dist/operations/members.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.js","sourceRoot":"","sources":["../../src/operations/members.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAGlE;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,SAAS,EAAE,eAAe;IAC1B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,IAAI,EAAE,iBAAiB;CACxB,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,SAAS,EAAE,eAAe;IAC1B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC1B,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,SAAS,EAAE,eAAe;CAC3B,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,GAAG,EAAE,aAAa,CAAC;QACjB,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,SAAS;QACjB,WAAW,EAAE,uEAAuE;QACpF,KAAK,EAAE,oBAAoB;QAC3B,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAC1B,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;KAC/E,CAAC;IACF,MAAM,EAAE,aAAa,CAAC;QACpB,IAAI,EAAE,gBAAgB;QACtB,MAAM,EAAE,SAAS;QACjB,WAAW,EAAE,iCAAiC;QAC9C,KAAK,EAAE,uBAAuB;QAC9B,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE;YAChC,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;YACzE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAA;QAC7D,CAAC;KACF,CAAC;IACF,IAAI,EAAE,WAAW,CAAC;QAChB,IAAI,EAAE,cAAc;QACpB,MAAM,EAAE,SAAS;QACjB,WAAW,EAAE,iDAAiD;QAC9D,KAAK,EAAE,sBAAsB;QAC7B,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,SAAS,CAAC;KAClF,CAAC;CACM,CAAA;AAEV,MAAM,UAAU,sBAAsB,CAAC,OAA0B;IAC/D,OAAO;QACL,GAAG,EAAE,aAAa,CAAC,OAAO,EAAE,0BAA0B,CAAC,GAAG,CAAC;QAC3D,MAAM,EAAE,aAAa,CAAC,OAAO,EAAE,0BAA0B,CAAC,MAAM,CAAC;QACjE,IAAI,EAAE,aAAa,CAAC,OAAO,EAAE,0BAA0B,CAAC,IAAI,CAAC;KAC9D,CAAA;AACH,CAAC"}

package/dist/operations/publishing.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import type { OperationsRuntime } from './core';
+/**
+ * Publishing operations (EC-139). Pins a graph revision live (or reverts it to
+ * draft) — the persistent counterpart to the studio's publish flow in the
+ * collaboration drawer. Single-environment (EC-179, vision AD-8): a deployment
+ * IS one environment, so there is no environment dimension and no promote —
+ * see `env-is-deployment-boundary`.
+ */
+export declare const publishInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    revision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const publishingRefInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, z.core.$strip>;
+export declare const publishingOperationDefinitions: {
+    readonly publish: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+        revision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, {
+        createdAt: string;
+        updatedAt: string;
+        projectId: string;
+        status: "draft" | "published";
+        publishedRevisionId?: string | undefined;
+        publishedRevision?: number | undefined;
+        publishedAt?: string | undefined;
+    }>;
+    readonly unpublish: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+    }, z.core.$strip>, {
+        createdAt: string;
+        updatedAt: string;
+        projectId: string;
+        status: "draft" | "published";
+        publishedRevisionId?: string | undefined;
+        publishedRevision?: number | undefined;
+        publishedAt?: string | undefined;
+    }>;
+    readonly getState: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+    }, z.core.$strip>, {
+        createdAt: string;
+        updatedAt: string;
+        projectId: string;
+        status: "draft" | "published";
+        publishedRevisionId?: string | undefined;
+        publishedRevision?: number | undefined;
+        publishedAt?: string | undefined;
+    } | undefined>;
+};
+export declare function createPublishingOperations(runtime: OperationsRuntime): {
+    publish: (input: {
+        projectId: string;
+        revision?: number | undefined;
+    }) => Promise<import("./core").OperationResult<{
+        createdAt: string;
+        updatedAt: string;
+        projectId: string;
+        status: "draft" | "published";
+        publishedRevisionId?: string | undefined;
+        publishedRevision?: number | undefined;
+        publishedAt?: string | undefined;
+    }>>;
+    unpublish: (input: {
+        projectId: string;
+    }) => Promise<import("./core").OperationResult<{
+        createdAt: string;
+        updatedAt: string;
+        projectId: string;
+        status: "draft" | "published";
+        publishedRevisionId?: string | undefined;
+        publishedRevision?: number | undefined;
+        publishedAt?: string | undefined;
+    }>>;
+    getState: (input: {
+        projectId: string;
+    }) => Promise<import("./core").OperationResult<{
+        createdAt: string;
+        updatedAt: string;
+        projectId: string;
+        status: "draft" | "published";
+        publishedRevisionId?: string | undefined;
+        publishedRevision?: number | undefined;
+        publishedAt?: string | undefined;
+    } | undefined>>;
+};
+export type PublishingOperations = ReturnType<typeof createPublishingOperations>;

package/dist/operations/publishing.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { projectIdSchema } from '@elytracms/core/studio-core';
+import { bindOperation, defineCommand, defineQuery } from './core';
+/**
+ * Publishing operations (EC-139). Pins a graph revision live (or reverts it to
+ * draft) — the persistent counterpart to the studio's publish flow in the
+ * collaboration drawer. Single-environment (EC-179, vision AD-8): a deployment
+ * IS one environment, so there is no environment dimension and no promote —
+ * see `env-is-deployment-boundary`.
+ */
+export const publishInputSchema = z.object({
+    projectId: projectIdSchema,
+    /** Graph revision number to publish; defaults to the latest revision. */
+    revision: z.number().int().positive().optional(),
+});
+export const publishingRefInputSchema = z.object({
+    projectId: projectIdSchema,
+});
+export const publishingOperationDefinitions = {
+    publish: defineCommand({
+        name: 'publishing.publish',
+        domain: 'publishing',
+        description: 'Publish a graph revision (latest when omitted).',
+        input: publishInputSchema,
+        execute: async (context, input) => {
+            const loaded = input.revision !== undefined
+                ? await context.adapter.graphs.getRevision(input.projectId, input.revision)
+                : await context.adapter.graphs.getLatest(input.projectId);
+            return context.adapter.publishing.publish(input.projectId, {
+                revisionId: loaded.revision.id,
+                revision: loaded.revision.revision,
+            });
+        },
+    }),
+    unpublish: defineCommand({
+        name: 'publishing.unpublish',
+        domain: 'publishing',
+        description: 'Revert to draft (must currently be published).',
+        input: publishingRefInputSchema,
+        execute: (context, input) => context.adapter.publishing.unpublish(input.projectId),
+    }),
+    getState: defineQuery({
+        name: 'publishing.getState',
+        domain: 'publishing',
+        description: 'Load the publishing state (undefined before the first publish).',
+        input: publishingRefInputSchema,
+        execute: (context, input) => context.adapter.publishing.findState(input.projectId),
+    }),
+};
+export function createPublishingOperations(runtime) {
+    return {
+        publish: bindOperation(runtime, publishingOperationDefinitions.publish),
+        unpublish: bindOperation(runtime, publishingOperationDefinitions.unpublish),
+        getState: bindOperation(runtime, publishingOperationDefinitions.getState),
+    };
+}
+//# sourceMappingURL=publishing.js.map

package/dist/operations/publishing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publishing.js","sourceRoot":"","sources":["../../src/operations/publishing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAGlE;;;;;;GAMG;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,SAAS,EAAE,eAAe;IAC1B,yEAAyE;IACzE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CACjD,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,SAAS,EAAE,eAAe;CAC3B,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG;IAC5C,OAAO,EAAE,aAAa,CAAC;QACrB,IAAI,EAAE,oBAAoB;QAC1B,MAAM,EAAE,YAAY;QACpB,WAAW,EAAE,iDAAiD;QAC9D,KAAK,EAAE,kBAAkB;QACzB,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE;YAChC,MAAM,MAAM,GACV,KAAK,CAAC,QAAQ,KAAK,SAAS;gBAC1B,CAAC,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC;gBAC3E,CAAC,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;YAC7D,OAAO,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE;gBACzD,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE;gBAC9B,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,QAAQ;aACnC,CAAC,CAAA;QACJ,CAAC;KACF,CAAC;IACF,SAAS,EAAE,aAAa,CAAC;QACvB,IAAI,EAAE,sBAAsB;QAC5B,MAAM,EAAE,YAAY;QACpB,WAAW,EAAE,gDAAgD;QAC7D,KAAK,EAAE,wBAAwB;QAC/B,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;KACnF,CAAC;IACF,QAAQ,EAAE,WAAW,CAAC;QACpB,IAAI,EAAE,qBAAqB;QAC3B,MAAM,EAAE,YAAY;QACpB,WAAW,EAAE,iEAAiE;QAC9E,KAAK,EAAE,wBAAwB;QAC/B,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;KACnF,CAAC;CACM,CAAA;AAEV,MAAM,UAAU,0BAA0B,CAAC,OAA0B;IACnE,OAAO;QACL,OAAO,EAAE,aAAa,CAAC,OAAO,EAAE,8BAA8B,CAAC,OAAO,CAAC;QACvE,SAAS,EAAE,aAAa,CAAC,OAAO,EAAE,8BAA8B,CAAC,SAAS,CAAC;QAC3E,QAAQ,EAAE,aAAa,CAAC,OAAO,EAAE,8BAA8B,CAAC,QAAQ,CAAC;KAC1E,CAAA;AACH,CAAC"}

package/dist/operations/references.d.ts

@@ -0,0 +1,222 @@
+import { z } from 'zod';
+import type { PersistenceAdapter } from '@elytracms/core/persistence';
+import type { OperationEvent, OperationEventBus, OperationsRuntime } from './core';
+/**
+ * Reference-index operations (EC-155, vision AD-6/AD-7).
+ *
+ * Two halves, one file (self-contained by design):
+ * 1. The query API — `references.inbound` / `references.outbound` lookups with
+ *    field/node-path granularity (the substrate for Milestone B deep links),
+ *    plus the `references.backfill` command that rebuilds a project's index.
+ * 2. {@link attachReferenceIndex} — an event-bus subscriber that keeps the
+ *    index maintained on write: document/graph/publishing command successes
+ *    trigger a recompute of the affected sources (replace-all-for-source, so
+ *    edits/deletes/unpublishes can never leave stale entries).
+ */
+export declare const outboundReferencesInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    source: z.ZodObject<{
+        type: z.ZodEnum<{
+            document: "document";
+            page: "page";
+            layout: "layout";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    variant: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+    }>>;
+}, z.core.$strip>;
+export declare const inboundReferencesInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    target: z.ZodObject<{
+        type: z.ZodEnum<{
+            asset: "asset";
+            document: "document";
+            component: "component";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    variant: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+    }>>;
+}, z.core.$strip>;
+export declare const backfillReferencesInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, z.core.$strip>;
+export declare const referenceBuildMarkerInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, z.core.$strip>;
+export declare const referenceOperationDefinitions: {
+    readonly outbound: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+        source: z.ZodObject<{
+            type: z.ZodEnum<{
+                document: "document";
+                page: "page";
+                layout: "layout";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        variant: z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            published: "published";
+        }>>;
+    }, z.core.$strip>, {
+        path: string;
+        target: {
+            type: "asset" | "document" | "component";
+            id: string;
+        };
+        kind: "relation-field" | "asset-field" | "rich-text-link" | "rich-text-node" | "component-usage" | "prop-binding" | "condition-binding";
+        source: {
+            type: "document" | "page" | "layout";
+            id: string;
+        };
+        projectId: string;
+        variant: "draft" | "published";
+    }[]>;
+    readonly inbound: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+        target: z.ZodObject<{
+            type: z.ZodEnum<{
+                asset: "asset";
+                document: "document";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        variant: z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            published: "published";
+        }>>;
+    }, z.core.$strip>, {
+        path: string;
+        target: {
+            type: "asset" | "document" | "component";
+            id: string;
+        };
+        kind: "relation-field" | "asset-field" | "rich-text-link" | "rich-text-node" | "component-usage" | "prop-binding" | "condition-binding";
+        source: {
+            type: "document" | "page" | "layout";
+            id: string;
+        };
+        projectId: string;
+        variant: "draft" | "published";
+    }[]>;
+    readonly backfill: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+    }, z.core.$strip>, {
+        path: string;
+        target: {
+            type: "asset" | "document" | "component";
+            id: string;
+        };
+        kind: "relation-field" | "asset-field" | "rich-text-link" | "rich-text-node" | "component-usage" | "prop-binding" | "condition-binding";
+        source: {
+            type: "document" | "page" | "layout";
+            id: string;
+        };
+        projectId: string;
+        variant: "draft" | "published";
+    }[]>;
+    readonly buildMarker: import("./core").OperationDefinition<z.ZodObject<{
+        projectId: z.ZodString;
+    }, z.core.$strip>, import("@elytracms/core/persistence").ReferenceIndexBuildMarker | null>;
+};
+export declare function createReferenceOperations(runtime: OperationsRuntime): {
+    outbound: (input: {
+        projectId: string;
+        source: {
+            type: "document" | "page" | "layout";
+            id: string;
+        };
+        variant?: "draft" | "published" | undefined;
+    }) => Promise<import("./core").OperationResult<{
+        path: string;
+        target: {
+            type: "asset" | "document" | "component";
+            id: string;
+        };
+        kind: "relation-field" | "asset-field" | "rich-text-link" | "rich-text-node" | "component-usage" | "prop-binding" | "condition-binding";
+        source: {
+            type: "document" | "page" | "layout";
+            id: string;
+        };
+        projectId: string;
+        variant: "draft" | "published";
+    }[]>>;
+    inbound: (input: {
+        projectId: string;
+        target: {
+            type: "asset" | "document" | "component";
+            id: string;
+        };
+        variant?: "draft" | "published" | undefined;
+    }) => Promise<import("./core").OperationResult<{
+        path: string;
+        target: {
+            type: "asset" | "document" | "component";
+            id: string;
+        };
+        kind: "relation-field" | "asset-field" | "rich-text-link" | "rich-text-node" | "component-usage" | "prop-binding" | "condition-binding";
+        source: {
+            type: "document" | "page" | "layout";
+            id: string;
+        };
+        projectId: string;
+        variant: "draft" | "published";
+    }[]>>;
+    backfill: (input: {
+        projectId: string;
+    }) => Promise<import("./core").OperationResult<{
+        path: string;
+        target: {
+            type: "asset" | "document" | "component";
+            id: string;
+        };
+        kind: "relation-field" | "asset-field" | "rich-text-link" | "rich-text-node" | "component-usage" | "prop-binding" | "condition-binding";
+        source: {
+            type: "document" | "page" | "layout";
+            id: string;
+        };
+        projectId: string;
+        variant: "draft" | "published";
+    }[]>>;
+    buildMarker: (input: {
+        projectId: string;
+    }) => Promise<import("./core").OperationResult<import("@elytracms/core/persistence").ReferenceIndexBuildMarker | null>>;
+};
+export type ReferenceOperations = ReturnType<typeof createReferenceOperations>;
+export interface AttachReferenceIndexOptions {
+    /**
+     * Observes index-update failures. Updates run outside the command pipeline and
+     * must never break it (mirrors the event bus's listener isolation), so
+     * failures are reported here instead of thrown.
+     */
+    onError?: (error: unknown, event: OperationEvent) => void;
+}
+export interface ReferenceIndexAttachment {
+    /** Stop listening (already-queued updates still run). */
+    detach: () => void;
+    /** Await every index update queued so far (updates are async; events are sync). */
+    flush: () => Promise<void>;
+}
+/**
+ * Subscribe the reference index to the EC-139 lifecycle event bus so it is
+ * maintained on every write:
+ *
+ * - `documents` command success → recompute that document's entries (or all
+ *   documents when the summary was truncated past the document identity);
+ *   deletes drop entries because the recompute of a missing document is empty.
+ * - `graph` command success → recompute the draft graph entries from the new
+ *   latest revision.
+ * - `publishing` command success → recompute the published graph entries from
+ *   the currently pinned revisions (unpublish included).
+ *
+ * Updates run on a serial queue for deterministic ordering; await
+ * {@link ReferenceIndexAttachment.flush} to observe a settled index.
+ */
+export declare function attachReferenceIndex(events: OperationEventBus, adapter: PersistenceAdapter, options?: AttachReferenceIndexOptions): ReferenceIndexAttachment;