@xpert-ai/plugin-spaces 0.0.0-stage → 0.3.0

package/dist/entities.js

@@ -0,0 +1,318 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Column, CreateDateColumn, Entity, Index, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+export class ScopedEntity {
+    id;
+    tenantId;
+    organizationId;
+    createdAt;
+    updatedAt;
+}
+__decorate([
+    PrimaryGeneratedColumn('uuid'),
+    __metadata("design:type", String)
+], ScopedEntity.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], ScopedEntity.prototype, "tenantId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], ScopedEntity.prototype, "organizationId", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], ScopedEntity.prototype, "createdAt", void 0);
+__decorate([
+    UpdateDateColumn(),
+    __metadata("design:type", Date)
+], ScopedEntity.prototype, "updatedAt", void 0);
+let Space = class Space extends ScopedEntity {
+    /** Storage and membership belong to this Project; Space only adds content metadata. */
+    projectId;
+    knowledgebaseId;
+    title;
+    ownerId;
+    visibility;
+    version;
+    deleted;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], Space.prototype, "projectId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], Space.prototype, "knowledgebaseId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 200 }),
+    __metadata("design:type", String)
+], Space.prototype, "title", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], Space.prototype, "ownerId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 20 }),
+    __metadata("design:type", String)
+], Space.prototype, "visibility", void 0);
+__decorate([
+    Column({ type: 'int', default: 1 }),
+    __metadata("design:type", Number)
+], Space.prototype, "version", void 0);
+__decorate([
+    Column({ type: 'boolean', default: false }),
+    __metadata("design:type", Boolean)
+], Space.prototype, "deleted", void 0);
+Space = __decorate([
+    Entity('plugin_spaces_space'),
+    Index(['tenantId', 'organizationId']),
+    Index('IDX_space_project', ['tenantId', 'organizationId', 'projectId'], { unique: true })
+], Space);
+export { Space };
+let SpaceItem = class SpaceItem extends ScopedEntity {
+    /** Immutable import receipt; content stays in the project file. A copy does not inherit remote ACLs. */
+    importOrigin;
+    /** Logical page parent; parentId continues to mean the physical file folder. */
+    parentPageId;
+    /** Original request title makes a retried create idempotent even after a later rename. */
+    childRequestTitle;
+    filePath;
+    fileHash;
+    syncStatus;
+    syncError;
+    knowledgeDocumentId;
+    indexedHash;
+    indexStatus;
+    indexError;
+    spaceId;
+    parentId;
+    createdById;
+    title;
+    kind;
+    version;
+    deleted;
+    projectedSequence;
+    markdown;
+    editorKey;
+    currentFileVersionId;
+    file;
+    artifactId;
+    artifactVersionId;
+};
+__decorate([
+    Column({ type: 'jsonb', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "importOrigin", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "parentPageId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 200, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "childRequestTitle", void 0);
+__decorate([
+    Column({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "filePath", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 64, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "fileHash", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 24, default: 'pending' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "syncStatus", void 0);
+__decorate([
+    Column({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "syncError", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "knowledgeDocumentId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 64, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "indexedHash", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 24, default: 'pending' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "indexStatus", void 0);
+__decorate([
+    Column({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "indexError", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "spaceId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "parentId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "createdById", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 200 }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "title", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 20 }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "kind", void 0);
+__decorate([
+    Column({ type: 'int', default: 1 }),
+    __metadata("design:type", Number)
+], SpaceItem.prototype, "version", void 0);
+__decorate([
+    Column({ type: 'boolean', default: false }),
+    __metadata("design:type", Boolean)
+], SpaceItem.prototype, "deleted", void 0);
+__decorate([
+    Column({ type: 'int', default: -1 }),
+    __metadata("design:type", Number)
+], SpaceItem.prototype, "projectedSequence", void 0);
+__decorate([
+    Column({ type: 'text', default: '' }),
+    __metadata("design:type", String)
+], SpaceItem.prototype, "markdown", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 100, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "editorKey", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "currentFileVersionId", void 0);
+__decorate([
+    Column({ type: 'jsonb', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "file", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "artifactId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceItem.prototype, "artifactVersionId", void 0);
+SpaceItem = __decorate([
+    Entity('plugin_spaces_item'),
+    Index(['tenantId', 'organizationId', 'spaceId']),
+    Index('IDX_space_page_parent', ['tenantId', 'organizationId', 'spaceId', 'parentPageId']),
+    Index('IDX_space_item_active_path', ['spaceId', 'filePath'], { unique: true, where: '"deleted" = false AND "filePath" IS NOT NULL' })
+], SpaceItem);
+export { SpaceItem };
+let SpaceFileVersion = class SpaceFileVersion extends ScopedEntity {
+    itemId;
+    createdById;
+    reference;
+    revisionId;
+    sha256;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceFileVersion.prototype, "itemId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceFileVersion.prototype, "createdById", void 0);
+__decorate([
+    Column({ type: 'jsonb' }),
+    __metadata("design:type", Object)
+], SpaceFileVersion.prototype, "reference", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceFileVersion.prototype, "revisionId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 64 }),
+    __metadata("design:type", String)
+], SpaceFileVersion.prototype, "sha256", void 0);
+SpaceFileVersion = __decorate([
+    Entity('plugin_spaces_file_version'),
+    Index(['tenantId', 'organizationId', 'itemId'])
+], SpaceFileVersion);
+export { SpaceFileVersion };
+/** Organizational placement only. Native resources keep one authoritative provider and
+ * stable project bundle; moving a library entry never duplicates business content. */
+let SpaceResourcePlacement = class SpaceResourcePlacement extends ScopedEntity {
+    spaceId;
+    contentId;
+    parentId;
+    version;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceResourcePlacement.prototype, "spaceId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceResourcePlacement.prototype, "contentId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceResourcePlacement.prototype, "parentId", void 0);
+__decorate([
+    Column({ type: 'int', default: 1 }),
+    __metadata("design:type", Number)
+], SpaceResourcePlacement.prototype, "version", void 0);
+SpaceResourcePlacement = __decorate([
+    Entity('plugin_spaces_resource_placement'),
+    Index('IDX_space_resource_placement', ['tenantId', 'organizationId', 'spaceId', 'contentId'], { unique: true })
+], SpaceResourcePlacement);
+export { SpaceResourcePlacement };
+/** Disposable revision-bound knowledge state, never a source body or permission cache. */
+let SpaceContentIndex = class SpaceContentIndex extends ScopedEntity {
+    spaceId;
+    contentId;
+    revision;
+    bindingRevision;
+    status;
+    documents;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceContentIndex.prototype, "spaceId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceContentIndex.prototype, "contentId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 256, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceContentIndex.prototype, "revision", void 0);
+__decorate([
+    Column({ type: 'int', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceContentIndex.prototype, "bindingRevision", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 24, default: 'pending' }),
+    __metadata("design:type", String)
+], SpaceContentIndex.prototype, "status", void 0);
+__decorate([
+    Column({ type: 'jsonb', default: () => "'[]'::jsonb" }),
+    __metadata("design:type", Array)
+], SpaceContentIndex.prototype, "documents", void 0);
+SpaceContentIndex = __decorate([
+    Entity('plugin_spaces_content_index'),
+    Index('IDX_space_content_index', ['tenantId', 'organizationId', 'spaceId', 'contentId'], { unique: true })
+], SpaceContentIndex);
+export { SpaceContentIndex };
+export const entities = [Space, SpaceItem, SpaceFileVersion, SpaceResourcePlacement, SpaceContentIndex];

package/dist/files.d.ts

@@ -0,0 +1,79 @@
+import type { SpaceActor } from './domain.js';
+import { type AgentMiddlewareRuntimeServiceApi } from '@xpert-ai/plugin-sdk';
+import { Repository } from 'typeorm';
+import { SpaceAccess } from './access.js';
+import { SpaceItem, SpaceFileVersion } from './entities.js';
+import { SpacePages } from './pages.js';
+import { SpaceDocuments } from './documents.js';
+import { SpaceKnowledge } from './knowledge.js';
+import { SpacesService } from './spaces.js';
+export declare class SpaceFiles {
+    private readonly access;
+    private readonly pages;
+    private readonly spaces;
+    private readonly documents;
+    private readonly knowledge;
+    private readonly versions;
+    private readonly runtime;
+    constructor(access: SpaceAccess, pages: SpacePages, spaces: SpacesService, documents: SpaceDocuments, knowledge: SpaceKnowledge, versions: Repository<SpaceFileVersion>, runtime: AgentMiddlewareRuntimeServiceApi);
+    put(actor: SpaceActor, itemId: string, buffer: Buffer, fileName: string, mimeType: string, revisionId?: string | null, updateCurrent?: boolean): Promise<SpaceFileVersion>;
+    /** Opaque file protocol. Editor plugins own parsing; this resource owns snapshots and CAS. */
+    editorRead(actor: SpaceActor, itemId: string): Promise<{
+        buffer: Buffer<ArrayBufferLike>;
+        revision: string;
+    }>;
+    private editorRevision;
+    editorWrite(actor: SpaceActor, itemId: string, expectedRevision: string, buffer: Buffer): Promise<{
+        revision: string;
+    }>;
+    readBytes(actor: SpaceActor, versionId: string): Promise<Buffer<ArrayBufferLike>>;
+    upload(actor: SpaceActor, spaceId: string, parentId: string | null, fileName: string, mimeType: string, buffer: Buffer): Promise<{
+        item: SpaceItem;
+        version: SpaceFileVersion;
+    }>;
+    get(actor: SpaceActor, versionId: string): Promise<SpaceFileVersion>;
+    list(actor: SpaceActor, itemId: string): Promise<SpaceFileVersion[]>;
+    exportPage(actor: SpaceActor, itemId: string): Promise<{
+        fileVersionId: string;
+        revisionId: string;
+        sequence: number;
+        artifactId: string;
+        versionId: string;
+        url: string;
+    }>;
+    collect(actor: SpaceActor, spaceId: string, parentId: string | null, artifactId: string, versionId: string): Promise<SpaceItem>;
+    artifactBytes(actor: SpaceActor, artifactId: string, versionId: string): Promise<{
+        artifact: import("@xpert-ai/plugin-sdk").ArtifactRecord;
+        version: import("@xpert-ai/plugin-sdk").ArtifactVersionRecord;
+        buffer: Buffer<ArrayBufferLike>;
+    }>;
+    available(actor: SpaceActor, page: number): Promise<{
+        items: {
+            id: string;
+            title: string | null | undefined;
+            versions: import("@xpert-ai/plugin-sdk").ArtifactVersionRecord[];
+        }[];
+        total: number;
+        page: number;
+        pageSize: number;
+    }>;
+    current(actor: SpaceActor, itemId: string): Promise<{
+        reference: {
+            userId: string;
+            projectId: string;
+            catalog: "projects";
+            source: "platform.workspace.files";
+            filePath: string;
+            scopeId: string;
+            workspacePath: string;
+            tenantId: string;
+            organizationId: string;
+        };
+        fileName: string;
+        mimeType: string;
+    }>;
+    openArtifact(actor: SpaceActor, itemId: string): Promise<{
+        artifact: import("@xpert-ai/plugin-sdk").ArtifactRecord;
+        version: import("@xpert-ai/plugin-sdk").ArtifactVersionRecord;
+    }>;
+}

package/dist/files.js

@@ -0,0 +1,228 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { BadRequestException, ConflictException, Inject, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ArtifactsRuntimeCapability, WorkspaceFilesRuntimeCapability, XPERT_AGENT_MIDDLEWARE_RUNTIME_TOKEN } from '@xpert-ai/plugin-sdk';
+import { Repository } from 'typeorm';
+import { createHash, randomUUID } from 'node:crypto';
+import { SpaceAccess } from './access.js';
+import { Space, SpaceItem, SpaceFileVersion } from './entities.js';
+import { SpacePages } from './pages.js';
+import { SpaceDocuments, contentHash } from './documents.js';
+import { SpaceKnowledge } from './knowledge.js';
+import { SpacesService } from './spaces.js';
+import { denied, PLUGIN, scoped } from './domain.js';
+let SpaceFiles = class SpaceFiles {
+    access;
+    pages;
+    spaces;
+    documents;
+    knowledge;
+    versions;
+    runtime;
+    constructor(access, pages, spaces, documents, knowledge, versions, runtime) {
+        this.access = access;
+        this.pages = pages;
+        this.spaces = spaces;
+        this.documents = documents;
+        this.knowledge = knowledge;
+        this.versions = versions;
+        this.runtime = runtime;
+    }
+    async put(actor, itemId, buffer, fileName, mimeType, revisionId = null, updateCurrent = true) {
+        const access = await this.access.resource(actor, itemId, 'write');
+        if (!access.space.projectId || !access.item || buffer.byteLength > 25 * 1024 * 1024)
+            throw denied();
+        const safeName = fileName.replace(/[\\/\u0000-\u001f]/gu, '_').replace(/^\.+/u, '_').slice(0, 180) || 'file';
+        const versionId = randomUUID();
+        // Space is a Project extension; current files and snapshots share its volume and ACL.
+        const folder = `.space-history/${itemId}/${versionId}`;
+        const scope = { ...scoped(actor), userId: actor.userId, catalog: 'projects',
+            projectId: access.space.projectId, scopeId: access.space.projectId };
+        const files = this.runtime.createScopedApi(scope).capabilities?.get(WorkspaceFilesRuntimeCapability);
+        if (!files)
+            throw new Error('spaces.files_unavailable');
+        const uploaded = await files.uploadBuffer({ ...scope, buffer, originalName: safeName, fileName: safeName, folder, mimeType });
+        const reference = { ...scope, source: 'platform.workspace.files',
+            filePath: uploaded.filePath, workspacePath: uploaded.filePath, originalName: safeName, mimeType, size: buffer.byteLength };
+        const version = await this.versions.save(this.versions.create({ ...scoped(actor), id: versionId, itemId,
+            createdById: actor.userId, reference, revisionId, sha256: createHash('sha256').update(buffer).digest('hex') }));
+        if (updateCurrent) {
+            await this.documents.write(actor, itemId, buffer);
+            await this.access.items.update({ ...scoped(actor), id: itemId }, { file: reference, currentFileVersionId: version.id });
+            await this.knowledge.sync(actor, access.space, access.item);
+        }
+        return version;
+    }
+    /** Opaque file protocol. Editor plugins own parsing; this resource owns snapshots and CAS. */
+    async editorRead(actor, itemId) {
+        const { item, space } = await this.access.resource(actor, itemId, 'read');
+        if (!item?.editorKey || !item.currentFileVersionId)
+            throw denied();
+        const disk = await this.documents.read(actor, space, item);
+        if (!disk || disk.sha256 !== item.fileHash)
+            throw new ConflictException('spaces.version_conflict');
+        return { buffer: disk.buffer, revision: this.editorRevision(item) };
+    }
+    editorRevision(item) {
+        // Metadata changes (move/trash/restore) invalidate a previously opened file as well.
+        return `${item.version}:${item.currentFileVersionId}:${item.fileHash}`;
+    }
+    async editorWrite(actor, itemId, expectedRevision, buffer) {
+        const access = await this.access.resource(actor, itemId, 'write');
+        const result = await this.access.items.manager.transaction(async (manager) => {
+            await manager.getRepository(Space).findOneOrFail({ where: { ...scoped(actor), id: access.space.id }, lock: { mode: 'pessimistic_write' } });
+            const repo = manager.getRepository(SpaceItem);
+            const item = await repo.findOneOrFail({ where: { ...scoped(actor), id: itemId }, lock: { mode: 'pessimistic_write' } });
+            await this.access.resource(actor, itemId, 'write');
+            if (!item.editorKey || !item.currentFileVersionId || !item.filePath || item.deleted)
+                throw denied();
+            if (this.editorRevision(item) !== expectedRevision)
+                throw new ConflictException('spaces.version_conflict');
+            const disk = await this.documents.read(actor, access.space, item);
+            if (!disk || disk.sha256 !== item.fileHash)
+                throw new ConflictException('spaces.version_conflict');
+            const version = await this.put(actor, itemId, buffer, item.filePath.split('/').pop() ?? item.title, item.file?.mimeType ?? 'application/octet-stream', null, false);
+            // ProjectFiles performs a second atomic hash check against edits made outside this resource.
+            await this.documents.api().write({ ...this.documents.scope(actor, access.space), path: item.filePath,
+                buffer, expectedHash: item.fileHash });
+            const updated = { ...item, currentFileVersionId: version.id, file: version.reference,
+                fileHash: contentHash(buffer), version: item.version + 1, syncStatus: 'ready', syncError: null };
+            await repo.update(item.id, { currentFileVersionId: updated.currentFileVersionId, file: updated.file,
+                fileHash: updated.fileHash, version: updated.version, syncStatus: updated.syncStatus, syncError: null });
+            return { revision: this.editorRevision(updated) };
+        });
+        await this.knowledge.sync(actor, access.space, await this.access.items.findOneByOrFail({ ...scoped(actor), id: itemId }));
+        return result;
+    }
+    async readBytes(actor, versionId) {
+        const version = await this.get(actor, versionId);
+        const files = this.runtime.createScopedApi(actor).capabilities?.get(WorkspaceFilesRuntimeCapability);
+        if (!files)
+            throw new Error('spaces.files_unavailable');
+        return (await files.readBuffer(version.reference)).buffer;
+    }
+    async upload(actor, spaceId, parentId, fileName, mimeType, buffer) {
+        await this.access.resource(actor, parentId ?? spaceId, 'write');
+        if (buffer.byteLength > 25 * 1024 * 1024)
+            throw new Error('spaces.file_too_large');
+        const item = await this.spaces.createItem(actor, { spaceId, parentId, title: fileName.slice(0, 200), kind: 'file' });
+        try {
+            return { item, version: await this.put(actor, item.id, buffer, fileName, mimeType) };
+        }
+        catch (error) {
+            await this.access.items.update({ ...scoped(actor), id: item.id }, { deleted: true });
+            throw error;
+        }
+    }
+    async get(actor, versionId) {
+        const version = await this.versions.findOneByOrFail({ ...scoped(actor), id: versionId });
+        await this.access.resource(actor, version.itemId, 'read');
+        return version;
+    }
+    async list(actor, itemId) {
+        await this.access.resource(actor, itemId, 'read');
+        return this.versions.find({ where: { ...scoped(actor), itemId }, order: { createdAt: 'DESC' } });
+    }
+    async exportPage(actor, itemId) {
+        const revision = await this.pages.checkpoint(actor, itemId, 'Export');
+        const access = await this.access.resource(actor, itemId, 'write');
+        const file = await this.put(actor, itemId, Buffer.from(revision.markdown || '\n', 'utf8'), `${access.item?.title ?? 'Page'}.md`, 'text/markdown', revision.id);
+        const artifacts = this.runtime.createScopedApi(actor).capabilities?.get(ArtifactsRuntimeCapability);
+        if (!artifacts)
+            throw new Error('spaces.artifacts_unavailable');
+        const artifact = await artifacts.createArtifact({ source: { pluginName: PLUGIN, resourceType: 'space-item', resourceId: itemId },
+            authorizationProviderKey: 'spaces', scope: { projectId: access.space.projectId, userId: null }, kind: 'markdown', title: access.item?.title });
+        const version = await artifacts.ensureArtifactVersion({ artifactId: artifact.id, idempotencyKey: `revision:${revision.id}`,
+            workspaceFileRef: file.reference, mimeType: 'text/markdown', fileName: file.reference.originalName, sha256: file.sha256,
+            sourceVersionId: revision.id });
+        const link = await artifacts.createArtifactLink({ artifactId: artifact.id, artifactVersionId: version.version.id,
+            versionMode: 'version', access: { mode: 'organization_all' }, presentation: { disposition: 'attachment', allowDownload: true } });
+        return { fileVersionId: file.id, revisionId: revision.id, sequence: revision.sequence, artifactId: artifact.id, versionId: version.version.id, url: link.publicUrl };
+    }
+    async collect(actor, spaceId, parentId, artifactId, versionId) {
+        await this.access.resource(actor, parentId ?? spaceId, 'write');
+        const { artifact, version, buffer } = await this.artifactBytes(actor, artifactId, versionId);
+        const item = await this.spaces.createItem(actor, { spaceId, parentId, title: version.fileName ?? artifact.title ?? 'Artifact', kind: 'artifact', artifactId, artifactVersionId: versionId });
+        try {
+            await this.put(actor, item.id, buffer, version.fileName ?? item.title, version.mimeType ?? 'application/octet-stream');
+        }
+        catch (error) {
+            await this.access.items.update(item.id, { deleted: true });
+            throw error;
+        }
+        return item;
+    }
+    async artifactBytes(actor, artifactId, versionId) {
+        const artifacts = this.runtime.createScopedApi(actor).capabilities?.get(ArtifactsRuntimeCapability);
+        if (!artifacts)
+            throw new Error('spaces.artifacts_unavailable');
+        const artifact = await artifacts.getArtifact(artifactId);
+        const version = (await artifacts.listArtifactVersions({ artifactId })).find((version) => version.id === versionId);
+        if (!version)
+            throw denied();
+        if (!version.workspaceFileRef)
+            throw new BadRequestException('spaces.artifact_file_unavailable');
+        // Collection can read another authorized project; its own ACL is checked by both
+        // Artifacts and WorkspaceFiles. The destination Project must not replace that scope.
+        const files = this.runtime.createScopedApi({ ...scoped(actor), userId: actor.userId }).capabilities?.get(WorkspaceFilesRuntimeCapability);
+        if (!files)
+            throw new Error('spaces.files_unavailable');
+        const bytes = await files.readBuffer(version.workspaceFileRef);
+        return { artifact, version, buffer: bytes.buffer };
+    }
+    async available(actor, page) {
+        await this.access.project(actor);
+        const api = this.runtime.createScopedApi(actor).capabilities?.require(ArtifactsRuntimeCapability);
+        if (!api)
+            throw new Error('spaces.artifacts_unavailable');
+        const result = await api.listArtifacts({ page, pageSize: 40 });
+        return { ...result, items: await Promise.all(result.items.map(async (artifact) => ({
+                id: artifact.id, title: artifact.title, versions: (await api.listArtifactVersions({ artifactId: artifact.id })).filter((version) => version.workspaceFileRef)
+            }))) };
+    }
+    async current(actor, itemId) {
+        const { item, space } = await this.access.resource(actor, itemId, 'read');
+        if (!space.projectId || !item?.filePath || item.kind === 'folder')
+            throw denied();
+        return { reference: { ...scoped(actor), userId: actor.userId, projectId: space.projectId,
+                catalog: 'projects', source: 'platform.workspace.files', filePath: item.filePath,
+                scopeId: space.projectId, workspacePath: item.filePath }, fileName: item.filePath.split('/').pop() ?? item.title,
+            mimeType: item.kind === 'page' ? 'text/markdown' : item.file?.mimeType ?? 'application/octet-stream' };
+    }
+    async openArtifact(actor, itemId) {
+        const access = await this.access.resource(actor, itemId, 'read');
+        if (!access.item?.artifactId)
+            throw denied();
+        // A collection is a reference. It never expands access to the original Artifact.
+        const artifacts = this.runtime.createScopedApi(actor).capabilities?.get(ArtifactsRuntimeCapability);
+        if (!artifacts)
+            throw new Error('spaces.artifacts_unavailable');
+        const artifact = await artifacts.getArtifact(access.item.artifactId);
+        const versions = await artifacts.listArtifactVersions({ artifactId: artifact.id });
+        const version = versions.find((entry) => entry.id === access.item?.artifactVersionId);
+        if (!version)
+            throw denied();
+        return { artifact, version };
+    }
+};
+SpaceFiles = __decorate([
+    Injectable(),
+    __param(5, InjectRepository(SpaceFileVersion)),
+    __param(6, Inject(XPERT_AGENT_MIDDLEWARE_RUNTIME_TOKEN)),
+    __metadata("design:paramtypes", [SpaceAccess, SpacePages, SpacesService,
+        SpaceDocuments,
+        SpaceKnowledge,
+        Repository, Object])
+], SpaceFiles);
+export { SpaceFiles };