@flowdular/sdk 0.2.4 → 0.3.1

package/modules/workflows/src/services/workflows-service.ts

@@ -41,19 +41,35 @@ import type {
 	WorkflowRevision,
 	WorkflowRunAccepted,
 	WorkflowRunDetail,
+	WorkflowAuditListQuery,
+	WorkflowDefinitionListQuery,
+	WorkflowDefinitionPage,
 	WorkflowRunEventV1,
-	WorkflowRunFilters,
+	WorkflowRunListQuery,
 	WorkflowRunPage,
 	WorkflowRunSummary,
 	WorkflowSimulationRequest,
+	WorkflowSortDirection,
 	WorkflowUsageRollupV1,
 } from '../domain/types.ts';
 import { WORKFLOW_LIMITS } from '../domain/types.ts';
 import { WORKFLOWS_PERMISSIONS } from '../acl/permissions.ts';
-import type { WorkflowCursorCodec } from './cursor-codec.ts';
+import {
+	APPROVALS_REQUESTS_CAPABILITY,
+	type ApprovalsRequests,
+	type WorkspaceRolesResolver,
+} from './approvals.ts';
+import {
+	readWorkflowCursor,
+	signWorkflowCursor,
+	type WorkflowCursorKeys,
+	type WorkflowCursorPayload,
+} from './cursors.ts';
 import { safePayloadEvidence } from './payload-codec.ts';
 import type {
 	WorkflowAuditPage,
+	WorkflowKeysetPage,
+	WorkflowKeysetPosition,
 	WorkflowRunRecord,
 	WorkflowsRepository,
 } from './repository.ts';
@@ -77,6 +93,69 @@ function pageLimit(
 	return value;
 }
 
+/**
+ * What a list cursor is bound to. A page is a position inside one ordered,
+ * narrowed set; a cursor presented with a different tenant, sort or filters
+ * would name a position in a set it was never read from, so it is refused.
+ */
+interface ListBinding<Sort extends string> {
+	readonly kind: 'definitions' | 'runs' | 'audit';
+	readonly tenantId: string;
+	readonly sort: Sort;
+	readonly direction: WorkflowSortDirection;
+	/** The filters in one canonical form, so equal filters compare equal. */
+	readonly filters: string;
+}
+
+function cursorInvalid(): WorkflowsServiceError {
+	return new WorkflowsServiceError(
+		'CURSOR_INVALID',
+		'The page cursor is not valid.',
+		400,
+	);
+}
+
+/** Only the filters that are set, in a fixed key order. */
+function canonicalFilters(
+	filters: Readonly<Record<string, string | undefined>>,
+): string {
+	const present: Record<string, string> = {};
+	for (const key of Object.keys(filters).sort()) {
+		const value = filters[key];
+		if (value !== undefined && value !== '') present[key] = value;
+	}
+	return JSON.stringify(present);
+}
+
+function direction(
+	value: WorkflowSortDirection | undefined,
+	fallback: WorkflowSortDirection,
+): WorkflowSortDirection {
+	if (value === undefined) return fallback;
+	if (value !== 'asc' && value !== 'desc') {
+		throw new WorkflowsServiceError(
+			'WORKFLOW_INPUT_INVALID',
+			'direction must be asc or desc.',
+		);
+	}
+	return value;
+}
+
+function sortKey<Sort extends string>(
+	value: Sort | undefined,
+	allowed: readonly Sort[],
+	fallback: Sort,
+): Sort {
+	if (value === undefined) return fallback;
+	if (!allowed.includes(value)) {
+		throw new WorkflowsServiceError(
+			'WORKFLOW_INPUT_INVALID',
+			`sort must be one of ${allowed.join(', ')}.`,
+		);
+	}
+	return value;
+}
+
 function parsedGraph(value: unknown): WorkflowGraphV1 {
 	try {
 		return parseWorkflowGraph(value);
@@ -125,7 +204,11 @@ export class WorkflowsServiceError extends Error {
 
 export interface WorkflowsServiceOptions {
 	readonly capabilities: PlatformCapabilityRegistry;
-	readonly cursorCodec: WorkflowCursorCodec;
+	readonly cursorKeys: WorkflowCursorKeys;
+	/* Roles the workspace defines, for the human-approval requirement check at
+	   publish time. Absent means no role can be confirmed, which the compiler
+	   reports the same way it reports an unknown one. */
+	readonly roles?: WorkspaceRolesResolver;
 	readonly now?: () => number;
 	readonly onRunQueued?: () => void;
 }
@@ -257,6 +340,12 @@ export class WorkflowsService {
 		);
 	}
 
+	#approvals(): ApprovalsRequests | null {
+		return this.options.capabilities.get<ApprovalsRequests>(
+			APPROVALS_REQUESTS_CAPABILITY,
+		);
+	}
+
 	/* Presence is separate from resolution: an absent capability is a 503 the
 	   caller reports before it reads a graph or a revision. */
 	#executionCapabilities(): WorkflowExecutionCapabilities | null {
@@ -274,6 +363,16 @@ export class WorkflowsService {
 	): Promise<WorkflowReferenceCatalog> {
 		const { agents, actions } = capabilities;
 		const actionDescriptors = await actions.listWorkflowActions();
+		const needsApproval = graph.nodes.some(
+			(node) => node.type === 'human-approval',
+		);
+		const approvals = needsApproval ? this.#approvals() : null;
+		/* Only asked for when a node needs it: resolving every workspace role is
+		   a query no graph without a human step should pay for. */
+		const roleKeys =
+			needsApproval && approvals !== null && this.options.roles
+				? await this.options.roles(context.tenantId)
+				: [];
 		const revisions = new Map<string, AgentRevisionReference | null>();
 		for (const node of graph.nodes) {
 			if (node.type !== 'agent' && node.type !== 'agent-decision') continue;
@@ -312,6 +411,7 @@ export class WorkflowsService {
 					allowedTools: reference?.allowedTools ?? [],
 				};
 			},
+			approval: () => ({ available: approvals !== null, roleKeys }),
 			action: (actionId, contractVersion) => {
 				const action = actionDescriptors.find(
 					(entry) =>
@@ -329,9 +429,88 @@ export class WorkflowsService {
 		};
 	}
 
-	async list(tenantId: string): Promise<readonly WorkflowDefinition[]> {
-		return await this.repository.listDefinitions(
-			bounded(tenantId, 'tenantId', 1, 128),
+	async listDefinitions(
+		tenantId: string,
+		query: WorkflowDefinitionListQuery = {},
+	): Promise<WorkflowDefinitionPage> {
+		const sort = sortKey(query.sort, ['name', 'updatedAt'], 'name');
+		const binding: ListBinding<typeof sort> = {
+			kind: 'definitions',
+			tenantId: bounded(tenantId, 'tenantId', 1, 128),
+			sort,
+			direction: direction(query.direction, 'asc'),
+			filters: canonicalFilters({
+				status: query.status,
+				search: query.search,
+			}),
+		};
+		const limit = pageLimit(
+			query.limit,
+			'limit',
+			WORKFLOW_LIMITS.maxInteractivePage,
+			50,
+		);
+		const page = await this.repository.listDefinitions(binding.tenantId, {
+			...(query.status ? { status: query.status } : {}),
+			...(query.search ? { search: query.search } : {}),
+			sort,
+			direction: binding.direction,
+			limit,
+			after: this.#listPosition(binding, query.cursor, sort === 'name'),
+		});
+		return {
+			definitions: page.items,
+			nextCursor: this.#nextListCursor(binding, page, limit),
+		};
+	}
+
+	/* The cursor a page issued names the row it ended on, inside the binding it
+	   was read under. Anything this service did not sign, or signed for another
+	   tenant, order or filter set, is one refusal. */
+	#listPosition<Sort extends string>(
+		binding: ListBinding<Sort>,
+		cursor: string | null | undefined,
+		textKey: boolean,
+	): WorkflowKeysetPosition | null {
+		if (!cursor) return null;
+		let payload: WorkflowCursorPayload;
+		try {
+			payload = readWorkflowCursor(cursor, this.options.cursorKeys);
+		} catch {
+			throw cursorInvalid();
+		}
+		if (
+			payload.kind !== binding.kind ||
+			payload.tenantId !== binding.tenantId ||
+			payload.sort !== binding.sort ||
+			payload.direction !== binding.direction ||
+			payload.filters !== binding.filters
+		) {
+			throw cursorInvalid();
+		}
+		const key = payload.key;
+		const id = payload.id;
+		if (
+			key === undefined ||
+			id === undefined ||
+			(typeof key === 'string') !== textKey
+		) {
+			throw cursorInvalid();
+		}
+		return { key, id };
+	}
+
+	/* A full page may still be the last one; the client stops when the cursor
+	   stops, which costs one empty page at most. */
+	#nextListCursor<Sort extends string, T>(
+		binding: ListBinding<Sort>,
+		page: WorkflowKeysetPage<T>,
+		limit: number,
+	): string | null {
+		if (!page.last || page.items.length < limit) return null;
+		return signWorkflowCursor(
+			{ ...binding, key: page.last.key, id: page.last.id },
+			this.options.cursorKeys,
 		);
 	}
 
@@ -888,6 +1067,21 @@ export class WorkflowsService {
 				risk: 'read',
 				idempotency: 'required',
 			}),
+			/* A simulation asks nobody: the requirement is still shape-checked, and
+			   the role it names is taken as defined so a draft can be rehearsed
+			   before the workspace has that role. A draft may carry no requirement
+			   yet, which the compiler reports rather than this read failing on it. */
+			approval: () => ({
+				available: true,
+				roleKeys: detail.draft.graph.nodes.flatMap((node) => {
+					if (node.type !== 'human-approval') return [];
+					const requirement: { roleKey?: unknown } | undefined =
+						node.requirement;
+					return typeof requirement?.roleKey === 'string'
+						? [requirement.roleKey]
+						: [];
+				}),
+			}),
 		});
 		if (!report.valid) {
 			throw new WorkflowsServiceError(
@@ -968,58 +1162,44 @@ export class WorkflowsService {
 
 	async listRuns(
 		tenantId: string,
-		filters: WorkflowRunFilters,
+		query: WorkflowRunListQuery = {},
 	): Promise<WorkflowRunPage> {
-		const normalizedTenant = bounded(tenantId, 'tenantId', 1, 128);
+		const sort = sortKey(query.sort, ['queuedAt'], 'queuedAt');
+		const binding: ListBinding<typeof sort> = {
+			kind: 'runs',
+			tenantId: bounded(tenantId, 'tenantId', 1, 128),
+			sort,
+			direction: direction(query.direction, 'desc'),
+			filters: canonicalFilters({
+				workflowId: query.workflowId,
+				mode: query.mode,
+				status: query.status,
+				actorKind: query.actorKind,
+				originKind: query.originKind,
+				search: query.search,
+			}),
+		};
 		const limit = pageLimit(
-			filters.limit,
+			query.limit,
 			'limit',
 			WORKFLOW_LIMITS.maxInteractivePage,
 			50,
 		);
-		const normalized = { ...filters, limit, cursor: null };
-		const filterDigest = jsonHash(normalized as unknown as JsonValue);
-		let rawCursor: string | null = null;
-		if (filters.cursor) {
-			try {
-				const decoded = this.options.cursorCodec.decode<{
-					readonly tenantId: string;
-					readonly filterDigest: string;
-					readonly raw: string;
-				}>('wfrc1', filters.cursor);
-				if (
-					decoded.tenantId !== normalizedTenant ||
-					decoded.filterDigest !== filterDigest
-				) {
-					throw new WorkflowsServiceError(
-						'WORKFLOW_CURSOR_MISMATCH',
-						'The run cursor belongs to another tenant or filter.',
-						409,
-					);
-				}
-				rawCursor = decoded.raw;
-			} catch (error) {
-				if (error instanceof WorkflowsServiceError) throw error;
-				throw new WorkflowsServiceError(
-					'WORKFLOW_CURSOR_INVALID',
-					'The run cursor is invalid.',
-				);
-			}
-		}
-		const page = await this.repository.listRuns(normalizedTenant, {
-			...filters,
+		const page = await this.repository.listRuns(binding.tenantId, {
+			...(query.workflowId ? { workflowId: query.workflowId } : {}),
+			...(query.mode ? { mode: query.mode } : {}),
+			...(query.status ? { status: query.status } : {}),
+			...(query.actorKind ? { actorKind: query.actorKind } : {}),
+			...(query.originKind ? { originKind: query.originKind } : {}),
+			...(query.search ? { search: query.search } : {}),
+			sort,
+			direction: binding.direction,
 			limit,
-			cursor: rawCursor,
+			after: this.#listPosition(binding, query.cursor, false),
 		});
 		return {
-			runs: page.runs,
-			nextCursor: page.nextCursor
-				? this.options.cursorCodec.encode('wfrc1', {
-						tenantId: normalizedTenant,
-						filterDigest,
-						raw: page.nextCursor,
-					})
-				: null,
+			runs: page.items,
+			nextCursor: this.#nextListCursor(binding, page, limit),
 		};
 	}
 
@@ -1093,34 +1273,36 @@ export class WorkflowsService {
 				'The event sequence is invalid.',
 			);
 		}
-		return this.options.cursorCodec.encode('wfre1', {
-			tenantId: bounded(tenantId, 'tenantId', 1, 128),
-			runId: bounded(runId, 'runId', 1, 128),
-			sequence,
-		});
+		return signWorkflowCursor(
+			{
+				kind: 'events',
+				tenantId: bounded(tenantId, 'tenantId', 1, 128),
+				runId: bounded(runId, 'runId', 1, 128),
+				sequence,
+			},
+			this.options.cursorKeys,
+		);
 	}
 
 	eventSequence(tenantId: string, runId: string, cursor: string): number {
 		try {
-			const decoded = this.options.cursorCodec.decode<{
-				readonly tenantId: string;
-				readonly runId: string;
-				readonly sequence: number;
-			}>('wfre1', cursor);
+			const decoded = readWorkflowCursor(cursor, this.options.cursorKeys);
+			const sequence = decoded.sequence;
 			if (
+				decoded.kind !== 'events' ||
 				decoded.tenantId !== bounded(tenantId, 'tenantId', 1, 128) ||
 				decoded.runId !== bounded(runId, 'runId', 1, 128) ||
-				!Number.isSafeInteger(decoded.sequence) ||
-				decoded.sequence < 0
+				typeof sequence !== 'number' ||
+				!Number.isSafeInteger(sequence) ||
+				sequence < 0
 			) {
 				throw new Error('cursor-binding');
 			}
-			return decoded.sequence;
+			return sequence;
 		} catch {
 			throw new WorkflowsServiceError(
 				'WORKFLOW_EVENT_CURSOR_INVALID',
 				'The event cursor is invalid for this workflow run.',
-				409,
 			);
 		}
 	}
@@ -1253,52 +1435,31 @@ export class WorkflowsService {
 
 	async listAudit(
 		tenantId: string,
-		limit: number,
-		cursor?: string | null,
+		query: WorkflowAuditListQuery = {},
 	): Promise<WorkflowAuditPage> {
-		const normalizedTenant = bounded(tenantId, 'tenantId', 1, 128);
-		const pageSize = pageLimit(
-			limit,
+		const sort = sortKey(query.sort, ['sequence', 'occurredAt'], 'sequence');
+		const binding: ListBinding<typeof sort> = {
+			kind: 'audit',
+			tenantId: bounded(tenantId, 'tenantId', 1, 128),
+			sort,
+			direction: direction(query.direction, 'desc'),
+			filters: canonicalFilters({}),
+		};
+		const limit = pageLimit(
+			query.limit,
 			'limit',
 			WORKFLOW_LIMITS.maxInteractivePage,
 			50,
 		);
-		let beforeSequence: number | undefined;
-		if (cursor) {
-			try {
-				const decoded = this.options.cursorCodec.decode<{
-					readonly tenantId: string;
-					readonly beforeSequence: number;
-				}>('wfac1', cursor);
-				if (decoded.tenantId !== normalizedTenant) {
-					throw new WorkflowsServiceError(
-						'WORKFLOW_CURSOR_MISMATCH',
-						'The audit cursor belongs to another tenant.',
-						409,
-					);
-				}
-				beforeSequence = decoded.beforeSequence;
-			} catch (error) {
-				if (error instanceof WorkflowsServiceError) throw error;
-				throw new WorkflowsServiceError(
-					'WORKFLOW_CURSOR_INVALID',
-					'The audit cursor is invalid.',
-				);
-			}
-		}
-		const page = await this.repository.listAudit(
-			normalizedTenant,
-			pageSize,
-			beforeSequence,
-		);
+		const page = await this.repository.listAudit(binding.tenantId, {
+			sort,
+			direction: binding.direction,
+			limit,
+			after: this.#listPosition(binding, query.cursor, false),
+		});
 		return {
-			events: page.events,
-			nextCursor: page.nextCursor
-				? this.options.cursorCodec.encode('wfac1', {
-						tenantId: normalizedTenant,
-						beforeSequence: Number(page.nextCursor),
-					})
-				: null,
+			events: page.items,
+			nextCursor: this.#nextListCursor(binding, page, limit),
 		};
 	}
 

package/modules/workflows/translations/en.json

@@ -63,6 +63,10 @@
 	"palette.add": "Add step",
 	"palette.noCompatible": "No step has an input compatible with this output.",
 	"common.filters": "Filters",
+	"pagination.label": "Pages",
+	"pagination.previous": "Previous",
+	"pagination.next": "Next",
+	"pagination.summary": "Page {page} · from {from}",
 	"common.none": "None",
 	"common.notAvailable": "N/A",
 	"common.refreshing": "Refreshing…",
@@ -73,7 +77,6 @@
 	"action.delete": "Delete",
 	"table.title": "Workflow definitions",
 	"table.caption": "Workflow definitions",
-	"table.count": "{count} workflows",
 	"table.column.workflow": "Workflow",
 	"table.column.draft": "Draft",
 	"table.column.published": "Published",
@@ -130,6 +133,7 @@
 	"nodeType.gate": "Gate",
 	"nodeType.validator": "Validator",
 	"nodeType.action": "Action",
+	"nodeType.human-approval": "Human approval",
 	"nodeType.merge": "Merge",
 	"nodeType.output": "Output",
 	"canvas.label": "Workflow graph canvas",
@@ -180,6 +184,13 @@
 	"inspector.emitFailure": "Follow failure port",
 	"inspector.failRun": "Fail the workflow run",
 	"inspector.schema": "Validation schema",
+	"inspector.approvalRole": "Deciding role",
+	"inspector.approvalRoleHelp": "A workspace role. Members holding it may decide; the role must exist when the workflow is published.",
+	"inspector.approvalScope": "Deciding permission",
+	"inspector.approvalScopeHelp": "Optional. Members must also hold this permission.",
+	"inspector.approvalDecisions": "Approvals needed",
+	"inspector.approvalExpiryDays": "Expires after (days)",
+	"inspector.approvalPrompt": "Question shown to the deciders",
 	"inspector.gatePointer": "Required JSON pointer",
 	"inspector.gatePointerHelp": "The gate passes when this path exists in its input.",
 	"inspector.mappings": "Input mappings",
@@ -249,7 +260,6 @@
 	"delete.description": "Only an unpublished workflow with no execution history can be deleted.",
 	"delete.confirm": "Delete workflow",
 	"history.title": "Execution history",
-	"history.count": "{count} runs",
 	"history.caption": "Workflow execution history",
 	"history.column.workflow": "Workflow",
 	"history.column.origin": "Actor and origin",
@@ -264,8 +274,6 @@
 	"history.statusFilter": "Run status",
 	"history.allStatuses": "All run statuses",
 	"history.loading": "Loading execution history…",
-	"history.loadingMore": "Loading…",
-	"history.loadMore": "Load more",
 	"history.emptyTitle": "No runs yet",
 	"history.emptyHint": "Simulations and live runs appear here with their current status.",
 	"history.filteredTitle": "No matching runs",

package/modules/workflows/translations/pl.json

@@ -63,6 +63,10 @@
 	"palette.add": "Dodaj krok",
 	"palette.noCompatible": "Żaden krok nie ma wejścia pasującego do tego wyjścia.",
 	"common.filters": "Filtry",
+	"pagination.label": "Strony",
+	"pagination.previous": "Poprzednia",
+	"pagination.next": "Następna",
+	"pagination.summary": "Strona {page} · od {from}",
 	"common.none": "Brak",
 	"common.notAvailable": "Brak danych",
 	"common.refreshing": "Odświeżanie…",
@@ -73,7 +77,6 @@
 	"action.delete": "Usuń",
 	"table.title": "Definicje workflow",
 	"table.caption": "Definicje workflow",
-	"table.count": "Workflow: {count}",
 	"table.column.workflow": "Workflow",
 	"table.column.draft": "Wersja robocza",
 	"table.column.published": "Opublikowana",
@@ -130,6 +133,7 @@
 	"nodeType.gate": "Bramka",
 	"nodeType.validator": "Walidator",
 	"nodeType.action": "Akcja",
+	"nodeType.human-approval": "Akceptacja człowieka",
 	"nodeType.merge": "Scalenie",
 	"nodeType.output": "Wyjście",
 	"canvas.label": "Obszar grafu workflow",
@@ -180,6 +184,13 @@
 	"inspector.emitFailure": "Przejdź portem błędu",
 	"inspector.failRun": "Zakończ wykonanie błędem",
 	"inspector.schema": "Schemat walidacji",
+	"inspector.approvalRole": "Rola decydująca",
+	"inspector.approvalRoleHelp": "Rola w obszarze roboczym. Jej członkowie mogą decydować; rola musi istnieć przy publikacji przepływu.",
+	"inspector.approvalScope": "Uprawnienie decydujące",
+	"inspector.approvalScopeHelp": "Opcjonalne. Członkowie muszą dodatkowo mieć to uprawnienie.",
+	"inspector.approvalDecisions": "Wymagane akceptacje",
+	"inspector.approvalExpiryDays": "Wygasa po (dniach)",
+	"inspector.approvalPrompt": "Pytanie pokazywane osobom decydującym",
 	"inspector.gatePointer": "Wymagany wskaźnik JSON",
 	"inspector.gatePointerHelp": "Bramka przechodzi, gdy ta ścieżka istnieje w danych wejściowych.",
 	"inspector.mappings": "Mapowania wejścia",
@@ -249,7 +260,6 @@
 	"delete.description": "Można usunąć tylko nieopublikowany workflow bez historii wykonań.",
 	"delete.confirm": "Usuń workflow",
 	"history.title": "Historia wykonań",
-	"history.count": "Wykonania: {count}",
 	"history.caption": "Historia wykonań workflow",
 	"history.column.workflow": "Workflow",
 	"history.column.origin": "Aktor i źródło",
@@ -264,8 +274,6 @@
 	"history.statusFilter": "Status wykonania",
 	"history.allStatuses": "Wszystkie statusy wykonań",
 	"history.loading": "Ładowanie historii wykonań…",
-	"history.loadingMore": "Ładowanie…",
-	"history.loadMore": "Załaduj więcej",
 	"history.emptyTitle": "Nie ma jeszcze wykonań",
 	"history.emptyHint": "Symulacje i uruchomienia na żywo pojawią się tutaj wraz z bieżącym statusem.",
 	"history.filteredTitle": "Brak pasujących wykonań",

package/modules.json

@@ -1,10 +1,6 @@
 {
 	"schemaVersion": 1,
 	"modules": [
-		{
-			"manifest": "modules/automations-workflows-integration/module.json",
-			"import": "@flowdular/sdk/modules/automations-workflows-integration"
-		},
 		{
 			"manifest": "modules/auth/module.json",
 			"import": "@flowdular/sdk/modules/auth"
@@ -36,6 +32,54 @@
 		{
 			"manifest": "modules/automations/module.json",
 			"import": "@flowdular/sdk/modules/automations"
+		},
+		{
+			"manifest": "modules/notifications/module.json",
+			"import": "@flowdular/sdk/modules/notifications"
+		},
+		{
+			"manifest": "modules/directory/module.json",
+			"import": "@flowdular/sdk/modules/directory"
+		},
+		{
+			"manifest": "modules/audit/module.json",
+			"import": "@flowdular/sdk/modules/audit"
+		},
+		{
+			"manifest": "modules/approvals/module.json",
+			"import": "@flowdular/sdk/modules/approvals"
+		},
+		{
+			"manifest": "modules/documents/module.json",
+			"import": "@flowdular/sdk/modules/documents"
+		},
+		{
+			"manifest": "modules/metering/module.json",
+			"import": "@flowdular/sdk/modules/metering"
+		},
+		{
+			"manifest": "modules/search/module.json",
+			"import": "@flowdular/sdk/modules/search"
+		},
+		{
+			"manifest": "modules/connectors/module.json",
+			"import": "@flowdular/sdk/modules/connectors"
+		},
+		{
+			"manifest": "modules/import/module.json",
+			"import": "@flowdular/sdk/modules/import"
+		},
+		{
+			"manifest": "modules/reports/module.json",
+			"import": "@flowdular/sdk/modules/reports"
+		},
+		{
+			"manifest": "modules/access/module.json",
+			"import": "@flowdular/sdk/modules/access"
+		},
+		{
+			"manifest": "modules/exports/module.json",
+			"import": "@flowdular/sdk/modules/exports"
 		}
 	]
 }