@webiny/api-workflows 0.0.0-unstable.0156a4c312

package/features/review/ReviewSaver/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ReviewSaver = createAbstraction("ReviewSaver");
+export { ReviewSaver };
+
+//# sourceMappingURL=abstractions.js.map

package/features/review/ReviewSaver/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewSaver/abstractions.js","sources":["../../../../src/features/review/ReviewSaver/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { Review } from \"~/domain/review/Review.js\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\nimport type {\n    ReviewNotFoundError,\n    ReviewPersistenceError,\n    ReviewTargetSyncError\n} from \"~/domain/review/errors.js\";\n\nexport type ReviewSaverError = ReviewNotFoundError | ReviewPersistenceError | ReviewTargetSyncError;\n\nexport interface IReviewSaver {\n    save(review: Review): Promise<Result<ReviewData, ReviewSaverError>>;\n}\n\n/**\n * The single save path for reviews (R10, D19, D52): prepare the review-level fields, persist\n * (create a new review, update an existing one; a deleted one is not re-created), write the facts' assignment records (R117; a failed write is only logged),\n * sync `system.workflow`, then publish one event per recorded fact. A failed sync keeps the save\n * and the events and returns `ReviewTargetSyncError` (R16). A failed persist aborts the step run\n * tasks started by the recorded reaches (R143) before returning the persistence error.\n */\nexport const ReviewSaver = createAbstraction<IReviewSaver>(\"ReviewSaver\");\n\nexport namespace ReviewSaver {\n    export type Interface = IReviewSaver;\n    export type Error = ReviewSaverError;\n    export type Return = Promise<Result<ReviewData, ReviewSaverError>>;\n}\n"],"names":["ReviewSaver","createAbstraction"],"mappings":";AAsBO,MAAMA,cAAcC,kBAAgC"}

package/features/review/ReviewStepReacher/ReviewStepReacher.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { StepTypeRegistryService } from "../../../features/stepTypes/StepTypeRegistryService/index.js";
+import { ReviewStepReacher as ReviewStepReacherAbstraction } from "./abstractions.js";
+declare class ReviewStepReacherImpl implements ReviewStepReacherAbstraction.Interface {
+    private stepTypes;
+    constructor(stepTypes: StepTypeRegistryService.Interface);
+    reach(params: ReviewStepReacherAbstraction.Params): Promise<Result<void, ReviewStepReacherAbstraction.Error>>;
+}
+export declare const ReviewStepReacher: typeof ReviewStepReacherImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReviewStepReacher>;
+};
+export {};

package/features/review/ReviewStepReacher/ReviewStepReacher.js

@@ -0,0 +1,45 @@
+import { Result } from "@webiny/feature/api";
+import { getAutomationActor } from "../../../domain/automation/getAutomationActor.js";
+import { StepTypeRegistryService } from "../../stepTypes/StepTypeRegistryService/index.js";
+import { ReviewStepReacher } from "./abstractions.js";
+class ReviewStepReacherImpl {
+    constructor(stepTypes){
+        this.stepTypes = stepTypes;
+    }
+    async reach(params) {
+        const step = params.review.getStepToReach();
+        if (!step) return Result.ok();
+        const stepType = this.stepTypes.get(step.type);
+        if (!stepType) {
+            const reached = params.review.reachRun({
+                actor: params.actor,
+                owner: getAutomationActor(params.review.toData().createdBy),
+                taskId: null,
+                now: params.now
+            });
+            if (reached.isFail()) return Result.fail(reached.error);
+            const failed = params.review.fail({
+                stepId: step.id,
+                reason: `The step type "${step.type}" is not available.`,
+                now: params.now
+            });
+            if (failed.isFail()) return Result.fail(failed.error);
+            return Result.ok();
+        }
+        return stepType.reach({
+            review: params.review,
+            step,
+            actor: params.actor,
+            now: params.now
+        });
+    }
+}
+const ReviewStepReacher_ReviewStepReacher = ReviewStepReacher.createImplementation({
+    implementation: ReviewStepReacherImpl,
+    dependencies: [
+        StepTypeRegistryService
+    ]
+});
+export { ReviewStepReacher_ReviewStepReacher as ReviewStepReacher };
+
+//# sourceMappingURL=ReviewStepReacher.js.map

package/features/review/ReviewStepReacher/ReviewStepReacher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewStepReacher/ReviewStepReacher.js","sources":["../../../../src/features/review/ReviewStepReacher/ReviewStepReacher.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { getAutomationActor } from \"~/domain/automation/getAutomationActor.js\";\nimport { StepTypeRegistryService } from \"~/features/stepTypes/StepTypeRegistryService/index.js\";\nimport { ReviewStepReacher as ReviewStepReacherAbstraction } from \"./abstractions.js\";\n\nclass ReviewStepReacherImpl implements ReviewStepReacherAbstraction.Interface {\n    constructor(private stepTypes: StepTypeRegistryService.Interface) {}\n\n    async reach(\n        params: ReviewStepReacherAbstraction.Params\n    ): Promise<Result<void, ReviewStepReacherAbstraction.Error>> {\n        const step = params.review.getStepToReach();\n        if (!step) {\n            return Result.ok();\n        }\n\n        const stepType = this.stepTypes.get(step.type);\n        if (!stepType) {\n            // A workflow saved before its step type was removed keeps running from its snapshot\n            // (A53), so an unregistered type fails the step instead of leaving it pending. Like a\n            // run step that cannot start (R168), the step is reached first, without a task, so the\n            // reach is recorded; the built-in review type is always registered, so this is a run\n            // type and the requester's automation actor owns it.\n            const reached = params.review.reachRun({\n                actor: params.actor,\n                owner: getAutomationActor(params.review.toData().createdBy),\n                taskId: null,\n                now: params.now\n            });\n            if (reached.isFail()) {\n                return Result.fail(reached.error);\n            }\n            const failed = params.review.fail({\n                stepId: step.id,\n                reason: `The step type \"${step.type}\" is not available.`,\n                now: params.now\n            });\n            // Whatever `fail` returns is returned, never ignored (R159).\n            if (failed.isFail()) {\n                return Result.fail(failed.error);\n            }\n            return Result.ok();\n        }\n\n        return stepType.reach({\n            review: params.review,\n            step,\n            actor: params.actor,\n            now: params.now\n        });\n    }\n}\n\nexport const ReviewStepReacher = ReviewStepReacherAbstraction.createImplementation({\n    implementation: ReviewStepReacherImpl,\n    dependencies: [StepTypeRegistryService]\n});\n"],"names":["ReviewStepReacherImpl","stepTypes","params","step","Result","stepType","reached","getAutomationActor","failed","ReviewStepReacher","ReviewStepReacherAbstraction","StepTypeRegistryService"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,SAA4C,CAAE;aAA9CA,SAAS,GAATA;IAA+C;IAEnE,MAAM,MACFC,MAA2C,EACc;QACzD,MAAMC,OAAOD,OAAO,MAAM,CAAC,cAAc;QACzC,IAAI,CAACC,MACD,OAAOC,OAAO,EAAE;QAGpB,MAAMC,WAAW,IAAI,CAAC,SAAS,CAAC,GAAG,CAACF,KAAK,IAAI;QAC7C,IAAI,CAACE,UAAU;YAMX,MAAMC,UAAUJ,OAAO,MAAM,CAAC,QAAQ,CAAC;gBACnC,OAAOA,OAAO,KAAK;gBACnB,OAAOK,mBAAmBL,OAAO,MAAM,CAAC,MAAM,GAAG,SAAS;gBAC1D,QAAQ;gBACR,KAAKA,OAAO,GAAG;YACnB;YACA,IAAII,QAAQ,MAAM,IACd,OAAOF,OAAO,IAAI,CAACE,QAAQ,KAAK;YAEpC,MAAME,SAASN,OAAO,MAAM,CAAC,IAAI,CAAC;gBAC9B,QAAQC,KAAK,EAAE;gBACf,QAAQ,CAAC,eAAe,EAAEA,KAAK,IAAI,CAAC,mBAAmB,CAAC;gBACxD,KAAKD,OAAO,GAAG;YACnB;YAEA,IAAIM,OAAO,MAAM,IACb,OAAOJ,OAAO,IAAI,CAACI,OAAO,KAAK;YAEnC,OAAOJ,OAAO,EAAE;QACpB;QAEA,OAAOC,SAAS,KAAK,CAAC;YAClB,QAAQH,OAAO,MAAM;YACrBC;YACA,OAAOD,OAAO,KAAK;YACnB,KAAKA,OAAO,GAAG;QACnB;IACJ;AACJ;AAEO,MAAMO,sCAAoBC,kBAAAA,oBAAiD,CAAC;IAC/E,gBAAgBV;IAChB,cAAc;QAACW;KAAwB;AAC3C"}

package/features/review/ReviewStepReacher/abstractions.d.ts

@@ -0,0 +1,28 @@
+import { type Result } from "@webiny/feature/api";
+import type { Review } from "../../../domain/review/Review.js";
+import type { Actor } from "../../../domain/review/types.js";
+import type { ReviewInvalidStateError, ReviewStepNotCurrentError } from "../../../domain/review/errors.js";
+/** What `StepType.reach` and `Review.fail` / `Review.reachRun` can return (R159). */
+export type ReviewStepReacherError = ReviewInvalidStateError | ReviewStepNotCurrentError;
+export interface ReviewStepReacherParams {
+    review: Review;
+    /** Who caused the step to be reached (requester, or approver of the previous step). */
+    actor: Actor;
+    now: string;
+}
+export interface IReviewStepReacher {
+    reach(params: ReviewStepReacherParams): Promise<Result<void, ReviewStepReacherError>>;
+}
+/**
+ * The one code path for "step reached" (spec 5.2, D2, D6). No-op when the current step is not
+ * pending. Dispatches by step type through `StepTypeRegistryService` (R131): the `review` type
+ * resolves an assignment, the `automation` type triggers its background task (R149); a step whose
+ * type is not registered is failed with a reason. A failed step is not an error of the reach; an
+ * error of `reach`, `reachRun` or `fail` is returned as it is (R159).
+ */
+export declare const ReviewStepReacher: import("@webiny/di").Abstraction<IReviewStepReacher>;
+export declare namespace ReviewStepReacher {
+    type Interface = IReviewStepReacher;
+    type Params = ReviewStepReacherParams;
+    type Error = ReviewStepReacherError;
+}

package/features/review/ReviewStepReacher/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ReviewStepReacher = createAbstraction("ReviewStepReacher");
+export { ReviewStepReacher };
+
+//# sourceMappingURL=abstractions.js.map

package/features/review/ReviewStepReacher/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewStepReacher/abstractions.js","sources":["../../../../src/features/review/ReviewStepReacher/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { Review } from \"~/domain/review/Review.js\";\nimport type { Actor } from \"~/domain/review/types.js\";\nimport type { ReviewInvalidStateError, ReviewStepNotCurrentError } from \"~/domain/review/errors.js\";\n\n/** What `StepType.reach` and `Review.fail` / `Review.reachRun` can return (R159). */\nexport type ReviewStepReacherError = ReviewInvalidStateError | ReviewStepNotCurrentError;\n\nexport interface ReviewStepReacherParams {\n    review: Review;\n    /** Who caused the step to be reached (requester, or approver of the previous step). */\n    actor: Actor;\n    now: string;\n}\n\nexport interface IReviewStepReacher {\n    reach(params: ReviewStepReacherParams): Promise<Result<void, ReviewStepReacherError>>;\n}\n\n/**\n * The one code path for \"step reached\" (spec 5.2, D2, D6). No-op when the current step is not\n * pending. Dispatches by step type through `StepTypeRegistryService` (R131): the `review` type\n * resolves an assignment, the `automation` type triggers its background task (R149); a step whose\n * type is not registered is failed with a reason. A failed step is not an error of the reach; an\n * error of `reach`, `reachRun` or `fail` is returned as it is (R159).\n */\nexport const ReviewStepReacher = createAbstraction<IReviewStepReacher>(\"ReviewStepReacher\");\n\nexport namespace ReviewStepReacher {\n    export type Interface = IReviewStepReacher;\n    export type Params = ReviewStepReacherParams;\n    export type Error = ReviewStepReacherError;\n}\n"],"names":["ReviewStepReacher","createAbstraction"],"mappings":";AA0BO,MAAMA,oBAAoBC,kBAAsC"}

package/features/review/ReviewStepReacher/events.d.ts

@@ -0,0 +1,16 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ReviewStepReachedFact } from "../../../domain/review/facts.js";
+import type { ReviewEventPayload } from "../shared/events.js";
+/**
+ * ReviewStepReachedEvent - published after the review is saved.
+ */
+export declare class ReviewStepReachedEvent extends DomainEvent<ReviewEventPayload<ReviewStepReachedFact>> {
+    eventType: "Workflows/Review/StepReached";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ReviewStepReachedEvent>>;
+}
+export declare const ReviewStepReachedEventHandler: import("@webiny/di").Abstraction<IEventHandler<ReviewStepReachedEvent>>;
+export declare namespace ReviewStepReachedEventHandler {
+    type Interface = IEventHandler<ReviewStepReachedEvent>;
+    type Event = ReviewStepReachedEvent;
+}

package/features/review/ReviewStepReacher/events.js

@@ -0,0 +1,14 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class ReviewStepReachedEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ReviewStepReachedEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Workflows/Review/StepReached";
+    }
+}
+const ReviewStepReachedEventHandler = createAbstraction("ReviewStepReachedEventHandler");
+export { ReviewStepReachedEvent, ReviewStepReachedEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/review/ReviewStepReacher/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewStepReacher/events.js","sources":["../../../../src/features/review/ReviewStepReacher/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ReviewStepReachedFact } from \"~/domain/review/facts.js\";\nimport type { ReviewEventPayload } from \"../shared/events.js\";\n\n/**\n * ReviewStepReachedEvent - published after the review is saved.\n */\nexport class ReviewStepReachedEvent extends DomainEvent<ReviewEventPayload<ReviewStepReachedFact>> {\n    eventType = \"Workflows/Review/StepReached\" as const;\n\n    getHandlerAbstraction() {\n        return ReviewStepReachedEventHandler;\n    }\n}\n\nexport const ReviewStepReachedEventHandler = createAbstraction<\n    IEventHandler<ReviewStepReachedEvent>\n>(\"ReviewStepReachedEventHandler\");\n\nexport namespace ReviewStepReachedEventHandler {\n    export type Interface = IEventHandler<ReviewStepReachedEvent>;\n    export type Event = ReviewStepReachedEvent;\n}\n"],"names":["ReviewStepReachedEvent","DomainEvent","ReviewStepReachedEventHandler","createAbstraction"],"mappings":";;AASO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,gCAAgCC,kBAE3C"}

package/features/review/ReviewTargetEditor/abstractions.d.ts

@@ -0,0 +1,61 @@
+import type { Result } from "@webiny/feature/api";
+import type { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+export interface ReviewTargetEditorField {
+    /** The key `update` takes: a field id, or dotted ids for a nested object (`address.street`). */
+    path: string;
+    label: string;
+    /** The target's own field type, e.g. "text", "long-text", "number", "object". */
+    type: string;
+    value: unknown;
+    /** Whether `update` accepts this path (R172). The model is told, so it does not try the rest. */
+    writable: boolean;
+}
+export interface ReviewTargetContent {
+    title: string;
+    fields: ReviewTargetEditorField[];
+}
+export interface ReviewTargetEditorReadParams {
+    /** Namespace id, e.g. "cms.article" or "wb.page" (D41). */
+    model: string;
+    targetId: string;
+    targetRevisionId: string;
+}
+export interface ReviewTargetEditorUpdateParams extends ReviewTargetEditorReadParams {
+    /** The new values by field path, as read. */
+    values: Record<string, unknown>;
+}
+export interface ReviewTargetEditorUpdateResult {
+    /** The paths that were written. */
+    applied: string[];
+}
+export interface IReviewTargetEditor {
+    /** Whether this editor handles the namespace id, e.g. "cms.article" or "wb.page". */
+    canEdit(model: string): boolean;
+    /**
+     * The whole content under review, every field with `writable`. Fails with a
+     * `ReviewTargetEditorError` (target not found, not readable); never throws.
+     */
+    read(params: ReviewTargetEditorReadParams): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;
+    /**
+     * Writes the bounded set of fields (R172), atomically: any path that is unknown or read-only,
+     * or any value the target rejects, fails the whole call and writes nothing. It does not check
+     * permissions or stale state and does not apply the bypass: the tool that calls it does (R173).
+     * Never throws; a non-validation failure is logged by the adapter and answered with a generic
+     * message.
+     */
+    update(params: ReviewTargetEditorUpdateParams): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;
+}
+/**
+ * Reads and writes the content under review for the AI tools (spec 9.3). One implementation per
+ * namespace, registered by the app target adapters (`cms.*`, `wb.page`); the last registered match
+ * wins (A10). The engine reaches it only through `ReviewTargetEditorService`.
+ */
+export declare const ReviewTargetEditor: import("@webiny/di").Abstraction<IReviewTargetEditor>;
+export declare namespace ReviewTargetEditor {
+    type Interface = IReviewTargetEditor;
+    type Field = ReviewTargetEditorField;
+    type Content = ReviewTargetContent;
+    type ReadParams = ReviewTargetEditorReadParams;
+    type UpdateParams = ReviewTargetEditorUpdateParams;
+    type UpdateResult = ReviewTargetEditorUpdateResult;
+}

package/features/review/ReviewTargetEditor/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ReviewTargetEditor = createAbstraction("ReviewTargetEditor");
+export { ReviewTargetEditor };
+
+//# sourceMappingURL=abstractions.js.map

package/features/review/ReviewTargetEditor/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetEditor/abstractions.js","sources":["../../../../src/features/review/ReviewTargetEditor/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ReviewTargetEditorError } from \"~/domain/review/errors.js\";\n\nexport interface ReviewTargetEditorField {\n    /** The key `update` takes: a field id, or dotted ids for a nested object (`address.street`). */\n    path: string;\n    label: string;\n    /** The target's own field type, e.g. \"text\", \"long-text\", \"number\", \"object\". */\n    type: string;\n    value: unknown;\n    /** Whether `update` accepts this path (R172). The model is told, so it does not try the rest. */\n    writable: boolean;\n}\n\nexport interface ReviewTargetContent {\n    title: string;\n    fields: ReviewTargetEditorField[];\n}\n\nexport interface ReviewTargetEditorReadParams {\n    /** Namespace id, e.g. \"cms.article\" or \"wb.page\" (D41). */\n    model: string;\n    targetId: string;\n    targetRevisionId: string;\n}\n\nexport interface ReviewTargetEditorUpdateParams extends ReviewTargetEditorReadParams {\n    /** The new values by field path, as read. */\n    values: Record<string, unknown>;\n}\n\nexport interface ReviewTargetEditorUpdateResult {\n    /** The paths that were written. */\n    applied: string[];\n}\n\nexport interface IReviewTargetEditor {\n    /** Whether this editor handles the namespace id, e.g. \"cms.article\" or \"wb.page\". */\n    canEdit(model: string): boolean;\n    /**\n     * The whole content under review, every field with `writable`. Fails with a\n     * `ReviewTargetEditorError` (target not found, not readable); never throws.\n     */\n    read(\n        params: ReviewTargetEditorReadParams\n    ): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;\n    /**\n     * Writes the bounded set of fields (R172), atomically: any path that is unknown or read-only,\n     * or any value the target rejects, fails the whole call and writes nothing. It does not check\n     * permissions or stale state and does not apply the bypass: the tool that calls it does (R173).\n     * Never throws; a non-validation failure is logged by the adapter and answered with a generic\n     * message.\n     */\n    update(\n        params: ReviewTargetEditorUpdateParams\n    ): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;\n}\n\n/**\n * Reads and writes the content under review for the AI tools (spec 9.3). One implementation per\n * namespace, registered by the app target adapters (`cms.*`, `wb.page`); the last registered match\n * wins (A10). The engine reaches it only through `ReviewTargetEditorService`.\n */\nexport const ReviewTargetEditor = createAbstraction<IReviewTargetEditor>(\"ReviewTargetEditor\");\n\nexport namespace ReviewTargetEditor {\n    export type Interface = IReviewTargetEditor;\n    export type Field = ReviewTargetEditorField;\n    export type Content = ReviewTargetContent;\n    export type ReadParams = ReviewTargetEditorReadParams;\n    export type UpdateParams = ReviewTargetEditorUpdateParams;\n    export type UpdateResult = ReviewTargetEditorUpdateResult;\n}\n"],"names":["ReviewTargetEditor","createAbstraction"],"mappings":";AAgEO,MAAMA,qBAAqBC,kBAAuC"}

package/features/review/ReviewTargetEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { ReviewTargetEditor } from "./abstractions.js";
+export type { ReviewTargetContent, ReviewTargetEditorField, ReviewTargetEditorReadParams, ReviewTargetEditorUpdateParams, ReviewTargetEditorUpdateResult } from "./abstractions.js";

package/features/review/ReviewTargetEditor/index.js

@@ -0,0 +1 @@
+export { ReviewTargetEditor } from "./abstractions.js";

package/features/review/ReviewTargetEditorService/ReviewTargetEditorService.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+import { ReviewTargetEditor } from "../../../features/review/ReviewTargetEditor/abstractions.js";
+import { ReviewTargetEditorService as ReviewTargetEditorServiceAbstraction } from "./abstractions.js";
+declare class ReviewTargetEditorServiceImpl implements ReviewTargetEditorServiceAbstraction.Interface {
+    private editors;
+    constructor(editors: ReviewTargetEditor.Interface[]);
+    read(params: ReviewTargetEditor.ReadParams): Promise<Result<import("~/features/review/ReviewTargetEditor/abstractions.js").ReviewTargetContent, ReviewTargetEditorError>>;
+    update(params: ReviewTargetEditor.UpdateParams): Promise<Result<import("~/features/review/ReviewTargetEditor/abstractions.js").ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;
+}
+export declare const ReviewTargetEditorService: typeof ReviewTargetEditorServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReviewTargetEditorService>;
+};
+export {};

package/features/review/ReviewTargetEditorService/ReviewTargetEditorService.js

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+import { ReviewTargetEditor } from "../ReviewTargetEditor/abstractions.js";
+import { ReviewTargetEditorService } from "./abstractions.js";
+class ReviewTargetEditorServiceImpl {
+    constructor(editors){
+        this.editors = editors;
+    }
+    async read(params) {
+        const editor = [
+            ...this.editors
+        ].reverse().find((item)=>item.canEdit(params.model));
+        if (!editor) return Result.fail(new ReviewTargetEditorError("This target cannot be edited."));
+        return editor.read(params);
+    }
+    async update(params) {
+        const editor = [
+            ...this.editors
+        ].reverse().find((item)=>item.canEdit(params.model));
+        if (!editor) return Result.fail(new ReviewTargetEditorError("This target cannot be edited."));
+        return editor.update(params);
+    }
+}
+const ReviewTargetEditorService_ReviewTargetEditorService = ReviewTargetEditorService.createImplementation({
+    implementation: ReviewTargetEditorServiceImpl,
+    dependencies: [
+        [
+            ReviewTargetEditor,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { ReviewTargetEditorService_ReviewTargetEditorService as ReviewTargetEditorService };
+
+//# sourceMappingURL=ReviewTargetEditorService.js.map

package/features/review/ReviewTargetEditorService/ReviewTargetEditorService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetEditorService/ReviewTargetEditorService.js","sources":["../../../../src/features/review/ReviewTargetEditorService/ReviewTargetEditorService.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ReviewTargetEditorError } from \"~/domain/review/errors.js\";\nimport { ReviewTargetEditor } from \"~/features/review/ReviewTargetEditor/abstractions.js\";\nimport { ReviewTargetEditorService as ReviewTargetEditorServiceAbstraction } from \"./abstractions.js\";\n\nclass ReviewTargetEditorServiceImpl implements ReviewTargetEditorServiceAbstraction.Interface {\n    public constructor(private editors: ReviewTargetEditor.Interface[]) {}\n\n    public async read(params: ReviewTargetEditor.ReadParams) {\n        // Several editors may match (a generic one and a specific one); the last registered wins,\n        // the same rule as `ReviewTargetLoader` in `RequestReviewUseCase`.\n        const editor = [...this.editors].reverse().find(item => item.canEdit(params.model));\n        if (!editor) {\n            return Result.fail(new ReviewTargetEditorError(\"This target cannot be edited.\"));\n        }\n        return editor.read(params);\n    }\n\n    public async update(params: ReviewTargetEditor.UpdateParams) {\n        const editor = [...this.editors].reverse().find(item => item.canEdit(params.model));\n        if (!editor) {\n            return Result.fail(new ReviewTargetEditorError(\"This target cannot be edited.\"));\n        }\n        return editor.update(params);\n    }\n}\n\nexport const ReviewTargetEditorService = ReviewTargetEditorServiceAbstraction.createImplementation({\n    implementation: ReviewTargetEditorServiceImpl,\n    dependencies: [[ReviewTargetEditor, { multiple: true }]]\n});\n"],"names":["ReviewTargetEditorServiceImpl","editors","params","editor","item","Result","ReviewTargetEditorError","ReviewTargetEditorService","ReviewTargetEditorServiceAbstraction","ReviewTargetEditor"],"mappings":";;;;AAKA,MAAMA;IACF,YAA2BC,OAAuC,CAAE;aAAzCA,OAAO,GAAPA;IAA0C;IAErE,MAAa,KAAKC,MAAqC,EAAE;QAGrD,MAAMC,SAAS;eAAI,IAAI,CAAC,OAAO;SAAC,CAAC,OAAO,GAAG,IAAI,CAACC,CAAAA,OAAQA,KAAK,OAAO,CAACF,OAAO,KAAK;QACjF,IAAI,CAACC,QACD,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QAEnD,OAAOH,OAAO,IAAI,CAACD;IACvB;IAEA,MAAa,OAAOA,MAAuC,EAAE;QACzD,MAAMC,SAAS;eAAI,IAAI,CAAC,OAAO;SAAC,CAAC,OAAO,GAAG,IAAI,CAACC,CAAAA,OAAQA,KAAK,OAAO,CAACF,OAAO,KAAK;QACjF,IAAI,CAACC,QACD,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QAEnD,OAAOH,OAAO,MAAM,CAACD;IACzB;AACJ;AAEO,MAAMK,sDAA4BC,0BAAAA,oBAAyD,CAAC;IAC/F,gBAAgBR;IAChB,cAAc;QAAC;YAACS;YAAoB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC5D"}

package/features/review/ReviewTargetEditorService/abstractions.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from "@webiny/feature/api";
+import type { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+import type { ReviewTargetContent, ReviewTargetEditorReadParams, ReviewTargetEditorUpdateParams, ReviewTargetEditorUpdateResult } from "../../../features/review/ReviewTargetEditor/abstractions.js";
+export interface IReviewTargetEditorService {
+    /** Reads through the last registered editor that handles `params.model`. */
+    read(params: ReviewTargetEditorReadParams): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;
+    /** Writes through the last registered editor that handles `params.model`. */
+    update(params: ReviewTargetEditorUpdateParams): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;
+}
+/**
+ * Picks the target editor for a namespace (spec 9.3). Internal (D132): no permission checks, no
+ * stale check and no bypass; the AI tools that call it own those (R173).
+ */
+export declare const ReviewTargetEditorService: import("@webiny/di").Abstraction<IReviewTargetEditorService>;
+export declare namespace ReviewTargetEditorService {
+    type Interface = IReviewTargetEditorService;
+}

package/features/review/ReviewTargetEditorService/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ReviewTargetEditorService = createAbstraction("ReviewTargetEditorService");
+export { ReviewTargetEditorService };
+
+//# sourceMappingURL=abstractions.js.map

package/features/review/ReviewTargetEditorService/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetEditorService/abstractions.js","sources":["../../../../src/features/review/ReviewTargetEditorService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ReviewTargetEditorError } from \"~/domain/review/errors.js\";\nimport type {\n    ReviewTargetContent,\n    ReviewTargetEditorReadParams,\n    ReviewTargetEditorUpdateParams,\n    ReviewTargetEditorUpdateResult\n} from \"~/features/review/ReviewTargetEditor/abstractions.js\";\n\nexport interface IReviewTargetEditorService {\n    /** Reads through the last registered editor that handles `params.model`. */\n    read(\n        params: ReviewTargetEditorReadParams\n    ): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;\n    /** Writes through the last registered editor that handles `params.model`. */\n    update(\n        params: ReviewTargetEditorUpdateParams\n    ): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;\n}\n\n/**\n * Picks the target editor for a namespace (spec 9.3). Internal (D132): no permission checks, no\n * stale check and no bypass; the AI tools that call it own those (R173).\n */\nexport const ReviewTargetEditorService = createAbstraction<IReviewTargetEditorService>(\n    \"ReviewTargetEditorService\"\n);\n\nexport namespace ReviewTargetEditorService {\n    export type Interface = IReviewTargetEditorService;\n}\n"],"names":["ReviewTargetEditorService","createAbstraction"],"mappings":";AAyBO,MAAMA,4BAA4BC,kBACrC"}

package/features/review/ReviewTargetEditorService/index.d.ts

@@ -0,0 +1 @@
+export { ReviewTargetEditorService } from "./abstractions.js";

package/features/review/ReviewTargetEditorService/index.js

@@ -0,0 +1 @@
+export { ReviewTargetEditorService } from "./abstractions.js";

package/features/review/ReviewTargetFolderChain/abstractions.d.ts

@@ -0,0 +1,26 @@
+export interface ReviewTargetFolderChainParams {
+    /** Namespace id, e.g. "cms.article" or "wb.page". */
+    model: string;
+    folderId: string;
+}
+export interface IReviewTargetFolderChain {
+    /** Whether this adapter answers for the namespace. */
+    canHandle(model: string): boolean;
+    /**
+     * The folder and its ancestors, nearest first, as stored now (spec 6: a parent folder can
+     * move while a review runs, so routing reads the chain at step reach). Read without
+     * folder-level permissions. Throws when the folders cannot be read.
+     */
+    listFolderChainIds(params: ReviewTargetFolderChainParams): Promise<string[]>;
+}
+/**
+ * The engine's folder lookup for rule conditions (R114). One implementation per namespace,
+ * registered by the app adapters (ACO `GetFolderRepository` + `GetAncestorsUseCase`); the last
+ * registered match wins. No match while a folder rule needs the chain fails routing, which falls
+ * through to the pool (R116).
+ */
+export declare const ReviewTargetFolderChain: import("@webiny/di").Abstraction<IReviewTargetFolderChain>;
+export declare namespace ReviewTargetFolderChain {
+    type Interface = IReviewTargetFolderChain;
+    type Params = ReviewTargetFolderChainParams;
+}

package/features/review/ReviewTargetFolderChain/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ReviewTargetFolderChain = createAbstraction("ReviewTargetFolderChain");
+export { ReviewTargetFolderChain };
+
+//# sourceMappingURL=abstractions.js.map

package/features/review/ReviewTargetFolderChain/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetFolderChain/abstractions.js","sources":["../../../../src/features/review/ReviewTargetFolderChain/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface ReviewTargetFolderChainParams {\n    /** Namespace id, e.g. \"cms.article\" or \"wb.page\". */\n    model: string;\n    folderId: string;\n}\n\nexport interface IReviewTargetFolderChain {\n    /** Whether this adapter answers for the namespace. */\n    canHandle(model: string): boolean;\n    /**\n     * The folder and its ancestors, nearest first, as stored now (spec 6: a parent folder can\n     * move while a review runs, so routing reads the chain at step reach). Read without\n     * folder-level permissions. Throws when the folders cannot be read.\n     */\n    listFolderChainIds(params: ReviewTargetFolderChainParams): Promise<string[]>;\n}\n\n/**\n * The engine's folder lookup for rule conditions (R114). One implementation per namespace,\n * registered by the app adapters (ACO `GetFolderRepository` + `GetAncestorsUseCase`); the last\n * registered match wins. No match while a folder rule needs the chain fails routing, which falls\n * through to the pool (R116).\n */\nexport const ReviewTargetFolderChain =\n    createAbstraction<IReviewTargetFolderChain>(\"ReviewTargetFolderChain\");\n\nexport namespace ReviewTargetFolderChain {\n    export type Interface = IReviewTargetFolderChain;\n    export type Params = ReviewTargetFolderChainParams;\n}\n"],"names":["ReviewTargetFolderChain","createAbstraction"],"mappings":";AAyBO,MAAMA,0BACTC,kBAA4C"}

package/features/review/ReviewTargetFolderChain/index.d.ts

@@ -0,0 +1 @@
+export { ReviewTargetFolderChain } from "./abstractions.js";

package/features/review/ReviewTargetFolderChain/index.js

@@ -0,0 +1 @@
+export { ReviewTargetFolderChain } from "./abstractions.js";

package/features/review/ReviewTargetFolderChangeGuard/ReviewTargetFolderChangeGuard.d.ts

@@ -0,0 +1,13 @@
+import { ReviewTargetFolderChangeGuard as ReviewTargetFolderChangeGuardAbstraction } from "./abstractions.js";
+import { GetBoundWorkflowUseCase } from "../../../features/workflow/GetBoundWorkflow/index.js";
+import { ListTargetReviewsUseCase } from "../../../features/review/ListTargetReviews/index.js";
+declare class ReviewTargetFolderChangeGuardImpl implements ReviewTargetFolderChangeGuardAbstraction.Interface {
+    private getBoundWorkflow;
+    private listTargetReviews;
+    constructor(getBoundWorkflow: GetBoundWorkflowUseCase.Interface, listTargetReviews: ListTargetReviewsUseCase.Interface);
+    check(params: ReviewTargetFolderChangeGuardAbstraction.Params): ReviewTargetFolderChangeGuardAbstraction.Return;
+}
+export declare const ReviewTargetFolderChangeGuard: typeof ReviewTargetFolderChangeGuardImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReviewTargetFolderChangeGuard>;
+};
+export {};

package/features/review/ReviewTargetFolderChangeGuard/ReviewTargetFolderChangeGuard.js

@@ -0,0 +1,43 @@
+import { Result } from "@webiny/feature/api";
+import { ReviewTargetFolderChangeGuard } from "./abstractions.js";
+import { GetBoundWorkflowUseCase } from "../../workflow/GetBoundWorkflow/index.js";
+import { ListTargetReviewsUseCase } from "../ListTargetReviews/index.js";
+import { ReviewTargetLockedError } from "../../../domain/review/errors.js";
+class ReviewTargetFolderChangeGuardImpl {
+    constructor(getBoundWorkflow, listTargetReviews){
+        this.getBoundWorkflow = getBoundWorkflow;
+        this.listTargetReviews = listTargetReviews;
+    }
+    async check(params) {
+        const bound = await this.getBoundWorkflow.execute({
+            model: params.model
+        });
+        if (bound.isFail()) return Result.fail(bound.error);
+        if (!bound.value) return Result.ok();
+        const reviews = await this.listTargetReviews.execute({
+            model: params.model,
+            targetId: params.targetId,
+            state: "inProgress"
+        });
+        if (reviews.isFail()) return Result.fail(reviews.error);
+        const [inProgress] = reviews.value;
+        if (!inProgress) return Result.ok();
+        return Result.fail(new ReviewTargetLockedError({
+            reviewId: inProgress.id,
+            model: params.model,
+            targetRevisionId: inProgress.targetRevisionId,
+            reviewState: inProgress.state,
+            action: "move"
+        }));
+    }
+}
+const ReviewTargetFolderChangeGuard_ReviewTargetFolderChangeGuard = ReviewTargetFolderChangeGuard.createImplementation({
+    implementation: ReviewTargetFolderChangeGuardImpl,
+    dependencies: [
+        GetBoundWorkflowUseCase,
+        ListTargetReviewsUseCase
+    ]
+});
+export { ReviewTargetFolderChangeGuard_ReviewTargetFolderChangeGuard as ReviewTargetFolderChangeGuard };
+
+//# sourceMappingURL=ReviewTargetFolderChangeGuard.js.map

package/features/review/ReviewTargetFolderChangeGuard/ReviewTargetFolderChangeGuard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetFolderChangeGuard/ReviewTargetFolderChangeGuard.js","sources":["../../../../src/features/review/ReviewTargetFolderChangeGuard/ReviewTargetFolderChangeGuard.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ReviewTargetFolderChangeGuard as ReviewTargetFolderChangeGuardAbstraction } from \"./abstractions.js\";\nimport { GetBoundWorkflowUseCase } from \"~/features/workflow/GetBoundWorkflow/index.js\";\nimport { ListTargetReviewsUseCase } from \"~/features/review/ListTargetReviews/index.js\";\nimport { ReviewTargetLockedError } from \"~/domain/review/errors.js\";\n\nclass ReviewTargetFolderChangeGuardImpl\n    implements ReviewTargetFolderChangeGuardAbstraction.Interface\n{\n    public constructor(\n        private getBoundWorkflow: GetBoundWorkflowUseCase.Interface,\n        private listTargetReviews: ListTargetReviewsUseCase.Interface\n    ) {}\n\n    public async check(\n        params: ReviewTargetFolderChangeGuardAbstraction.Params\n    ): ReviewTargetFolderChangeGuardAbstraction.Return {\n        const bound = await this.getBoundWorkflow.execute({ model: params.model });\n        if (bound.isFail()) {\n            return Result.fail(bound.error);\n        }\n        if (!bound.value) {\n            return Result.ok();\n        }\n\n        const reviews = await this.listTargetReviews.execute({\n            model: params.model,\n            targetId: params.targetId,\n            state: \"inProgress\"\n        });\n        if (reviews.isFail()) {\n            return Result.fail(reviews.error);\n        }\n        const [inProgress] = reviews.value;\n        if (!inProgress) {\n            return Result.ok();\n        }\n\n        return Result.fail(\n            new ReviewTargetLockedError({\n                reviewId: inProgress.id,\n                model: params.model,\n                targetRevisionId: inProgress.targetRevisionId,\n                reviewState: inProgress.state,\n                action: \"move\"\n            })\n        );\n    }\n}\n\nexport const ReviewTargetFolderChangeGuard =\n    ReviewTargetFolderChangeGuardAbstraction.createImplementation({\n        implementation: ReviewTargetFolderChangeGuardImpl,\n        dependencies: [GetBoundWorkflowUseCase, ListTargetReviewsUseCase]\n    });\n"],"names":["ReviewTargetFolderChangeGuardImpl","getBoundWorkflow","listTargetReviews","params","bound","Result","reviews","inProgress","ReviewTargetLockedError","ReviewTargetFolderChangeGuard","ReviewTargetFolderChangeGuardAbstraction","GetBoundWorkflowUseCase","ListTargetReviewsUseCase"],"mappings":";;;;;AAMA,MAAMA;IAGF,YACYC,gBAAmD,EACnDC,iBAAqD,CAC/D;aAFUD,gBAAgB,GAAhBA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAa,MACTC,MAAuD,EACR;QAC/C,MAAMC,QAAQ,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAAE,OAAOD,OAAO,KAAK;QAAC;QACxE,IAAIC,MAAM,MAAM,IACZ,OAAOC,OAAO,IAAI,CAACD,MAAM,KAAK;QAElC,IAAI,CAACA,MAAM,KAAK,EACZ,OAAOC,OAAO,EAAE;QAGpB,MAAMC,UAAU,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC;YACjD,OAAOH,OAAO,KAAK;YACnB,UAAUA,OAAO,QAAQ;YACzB,OAAO;QACX;QACA,IAAIG,QAAQ,MAAM,IACd,OAAOD,OAAO,IAAI,CAACC,QAAQ,KAAK;QAEpC,MAAM,CAACC,WAAW,GAAGD,QAAQ,KAAK;QAClC,IAAI,CAACC,YACD,OAAOF,OAAO,EAAE;QAGpB,OAAOA,OAAO,IAAI,CACd,IAAIG,wBAAwB;YACxB,UAAUD,WAAW,EAAE;YACvB,OAAOJ,OAAO,KAAK;YACnB,kBAAkBI,WAAW,gBAAgB;YAC7C,aAAaA,WAAW,KAAK;YAC7B,QAAQ;QACZ;IAER;AACJ;AAEO,MAAME,8DACTC,8BAAAA,oBAA6D,CAAC;IAC1D,gBAAgBV;IAChB,cAAc;QAACW;QAAyBC;KAAyB;AACrE"}

package/features/review/ReviewTargetFolderChangeGuard/abstractions.d.ts

@@ -0,0 +1,35 @@
+import type { Result } from "@webiny/feature/api";
+import type { ReviewTargetLockedError } from "../../../domain/review/errors.js";
+import type { GetBoundWorkflowUseCase } from "../../../features/workflow/GetBoundWorkflow/index.js";
+import type { ListTargetReviewsUseCase } from "../../../features/review/ListTargetReviews/index.js";
+export interface ReviewTargetFolderChangeGuardParams {
+    /** Namespace id of the target, for example `cms.article` or `wb.page`. */
+    model: string;
+    /** The target (entry or page) whose folder the update changes. */
+    targetId: string;
+}
+type GuardError = ReviewTargetLockedError | GetBoundWorkflowUseCase.Error | ListTargetReviewsUseCase.Error;
+export interface IReviewTargetFolderChangeGuard {
+    /**
+     * Ok when the target may change folder. Fails with `ReviewTargetLockedError` when any of its
+     * revisions has an in-progress review on a bound namespace, or with the lookup's error when a
+     * lookup fails.
+     */
+    check(params: ReviewTargetFolderChangeGuardParams): Promise<Result<void, GuardError>>;
+}
+/**
+ * The move rule applied to updates, shared by the app adapters (D84, R55, A24). An update can
+ * relocate the target without a move event, and the save block only checks the updated revision,
+ * so a folder change is refused like a move while any review of the target (any revision) is in
+ * progress. The adapters call it only when the update changes the folder. Unlike the save block
+ * it does not honour the bypass. Internal (D132): no permission checks; the adapters' update
+ * handlers call it and throw its error.
+ */
+export declare const ReviewTargetFolderChangeGuard: import("@webiny/di").Abstraction<IReviewTargetFolderChangeGuard>;
+export declare namespace ReviewTargetFolderChangeGuard {
+    type Interface = IReviewTargetFolderChangeGuard;
+    type Params = ReviewTargetFolderChangeGuardParams;
+    type Error = GuardError;
+    type Return = Promise<Result<void, GuardError>>;
+}
+export {};

package/features/review/ReviewTargetFolderChangeGuard/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ReviewTargetFolderChangeGuard = createAbstraction("ReviewTargetFolderChangeGuard");
+export { ReviewTargetFolderChangeGuard };
+
+//# sourceMappingURL=abstractions.js.map

package/features/review/ReviewTargetFolderChangeGuard/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetFolderChangeGuard/abstractions.js","sources":["../../../../src/features/review/ReviewTargetFolderChangeGuard/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ReviewTargetLockedError } from \"~/domain/review/errors.js\";\nimport type { GetBoundWorkflowUseCase } from \"~/features/workflow/GetBoundWorkflow/index.js\";\nimport type { ListTargetReviewsUseCase } from \"~/features/review/ListTargetReviews/index.js\";\n\nexport interface ReviewTargetFolderChangeGuardParams {\n    /** Namespace id of the target, for example `cms.article` or `wb.page`. */\n    model: string;\n    /** The target (entry or page) whose folder the update changes. */\n    targetId: string;\n}\n\ntype GuardError =\n    | ReviewTargetLockedError\n    | GetBoundWorkflowUseCase.Error\n    | ListTargetReviewsUseCase.Error;\n\nexport interface IReviewTargetFolderChangeGuard {\n    /**\n     * Ok when the target may change folder. Fails with `ReviewTargetLockedError` when any of its\n     * revisions has an in-progress review on a bound namespace, or with the lookup's error when a\n     * lookup fails.\n     */\n    check(params: ReviewTargetFolderChangeGuardParams): Promise<Result<void, GuardError>>;\n}\n\n/**\n * The move rule applied to updates, shared by the app adapters (D84, R55, A24). An update can\n * relocate the target without a move event, and the save block only checks the updated revision,\n * so a folder change is refused like a move while any review of the target (any revision) is in\n * progress. The adapters call it only when the update changes the folder. Unlike the save block\n * it does not honour the bypass. Internal (D132): no permission checks; the adapters' update\n * handlers call it and throw its error.\n */\nexport const ReviewTargetFolderChangeGuard = createAbstraction<IReviewTargetFolderChangeGuard>(\n    \"ReviewTargetFolderChangeGuard\"\n);\n\nexport namespace ReviewTargetFolderChangeGuard {\n    export type Interface = IReviewTargetFolderChangeGuard;\n    export type Params = ReviewTargetFolderChangeGuardParams;\n    export type Error = GuardError;\n    export type Return = Promise<Result<void, GuardError>>;\n}\n"],"names":["ReviewTargetFolderChangeGuard","createAbstraction"],"mappings":";AAmCO,MAAMA,gCAAgCC,kBACzC"}

package/features/review/ReviewTargetFolderChangeGuard/index.d.ts

@@ -0,0 +1 @@
+export { ReviewTargetFolderChangeGuard } from "./abstractions.js";

package/features/review/ReviewTargetFolderChangeGuard/index.js

@@ -0,0 +1 @@
+export { ReviewTargetFolderChangeGuard } from "./abstractions.js";

package/features/review/ReviewTargetLoader/abstractions.d.ts

@@ -0,0 +1,26 @@
+import type { TargetContext } from "../../../domain/review/types.js";
+export interface ReviewTargetLoadParams {
+    model: string;
+    targetId: string;
+    targetRevisionId: string;
+}
+export interface ReviewTarget {
+    title: string;
+    context: TargetContext;
+}
+export interface IReviewTargetLoader {
+    /** Whether this loader handles the namespace id, e.g. "cms.article" or "wb.page". */
+    canLoad(model: string): boolean;
+    /** The target revision's title and typed context; `null` when the revision does not exist. */
+    load(params: ReviewTargetLoadParams): Promise<ReviewTarget | null>;
+}
+/**
+ * Loads the content under review (spec 9.3). One implementation per namespace, registered by the
+ * app target adapters (`cms.*`, `wb.page`); the last registered match wins (A10).
+ */
+export declare const ReviewTargetLoader: import("@webiny/di").Abstraction<IReviewTargetLoader>;
+export declare namespace ReviewTargetLoader {
+    type Interface = IReviewTargetLoader;
+    type LoadParams = ReviewTargetLoadParams;
+    type Target = ReviewTarget;
+}

package/features/review/ReviewTargetLoader/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ReviewTargetLoader = createAbstraction("ReviewTargetLoader");
+export { ReviewTargetLoader };
+
+//# sourceMappingURL=abstractions.js.map

package/features/review/ReviewTargetLoader/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetLoader/abstractions.js","sources":["../../../../src/features/review/ReviewTargetLoader/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { TargetContext } from \"~/domain/review/types.js\";\n\nexport interface ReviewTargetLoadParams {\n    model: string;\n    targetId: string;\n    targetRevisionId: string;\n}\n\nexport interface ReviewTarget {\n    title: string;\n    context: TargetContext;\n}\n\nexport interface IReviewTargetLoader {\n    /** Whether this loader handles the namespace id, e.g. \"cms.article\" or \"wb.page\". */\n    canLoad(model: string): boolean;\n    /** The target revision's title and typed context; `null` when the revision does not exist. */\n    load(params: ReviewTargetLoadParams): Promise<ReviewTarget | null>;\n}\n\n/**\n * Loads the content under review (spec 9.3). One implementation per namespace, registered by the\n * app target adapters (`cms.*`, `wb.page`); the last registered match wins (A10).\n */\nexport const ReviewTargetLoader = createAbstraction<IReviewTargetLoader>(\"ReviewTargetLoader\");\n\nexport namespace ReviewTargetLoader {\n    export type Interface = IReviewTargetLoader;\n    export type LoadParams = ReviewTargetLoadParams;\n    export type Target = ReviewTarget;\n}\n"],"names":["ReviewTargetLoader","createAbstraction"],"mappings":";AAyBO,MAAMA,qBAAqBC,kBAAuC"}

package/features/review/ReviewTargetLoader/index.d.ts

@@ -0,0 +1,2 @@
+export { ReviewTargetLoader } from "./abstractions.js";
+export type { ReviewTarget } from "./abstractions.js";

package/features/review/ReviewTargetLoader/index.js

@@ -0,0 +1 @@
+export { ReviewTargetLoader } from "./abstractions.js";