@artkit-ai/core 0.1.0 → 0.2.0

package/dist/service.js

@@ -1,6 +1,5 @@
-import { deepEqual } from './diff.js';
-import { applyOperations, batchTargets, envelopeOperationSchema, parseOperations, prepareContent, targetsOverlap, } from './engine.js';
-import { canTransition, summarize, titleSchema, } from './envelope.js';
+import { applyOperations, prepareContent } from './engine.js';
+import { summarize, titleSchema } from './envelope.js';
 import { ArtifactError, zodIssuesToErrorIssues } from './errors.js';
 import { createEventBus } from './events.js';
 import { t } from './i18n.js';
@@ -8,14 +7,9 @@ import { silentLogger } from './logger.js';
 import { migrateContent } from './migrations.js';
 import { delimitProjection } from './projection.js';
 import { sanitizeDeep } from './sanitize.js';
-export const DEFAULT_APPROVAL_POLICY = {
-    requireApprovalToPublish: true,
-    requireApprovalToExport: false,
-    requireApprovalToEditPublished: false,
-};
 /**
- * The high-level pipeline (spec §8.2): authorization, migration, baseVersion check with automatic rebase,
- * atomic apply, optimistic commit with retries, idempotency, events and metadata-only logging.
+ * The core pipeline (spec §9.1): authorization, migration, baseVersion check, atomic apply, optimistic commit, events
+ * and metadata-only logging. There is no history, approval or archive here: the harness decides what a save means.
  */
 export function createArtifactService(options) {
     const { registry, store } = options;
@@ -24,8 +18,6 @@ export function createArtifactService(options) {
     const metrics = options.metrics ?? {};
     const events = options.events ??
         createEventBus((error) => logger.error('event handler failed', { code: String(error) }));
-    const policy = { ...DEFAULT_APPROVAL_POLICY, ...options.policy };
-    const retries = options.commitRetries ?? 3;
     async function authorize(action, artifact, scope) {
         if (!options.authorize)
             return;
@@ -35,10 +27,10 @@ export function createArtifactService(options) {
             throw new ArtifactError('PERMISSION_DENIED', t(locale, 'PERMISSION_DENIED', { action }));
         }
     }
-    async function load(scope, id, version) {
-        const found = await store.get(scope, id, version === undefined ? undefined : { version });
+    async function load(scope, id) {
+        const found = await store.get(scope, id);
         if (!found) {
-            throw new ArtifactError('NOT_FOUND', t(locale, 'NOT_FOUND', { what: version ? `Version ${version}` : 'Artifact', id }), {
+            throw new ArtifactError('NOT_FOUND', t(locale, 'NOT_FOUND', { what: 'Artifact', id }), {
                 issues: [
                     {
                         path: 'id',
@@ -51,16 +43,16 @@ export function createArtifactService(options) {
         return migrated(found);
     }
     function migrated(artifact) {
-        const kind = registry.get(artifact.kind, locale);
-        const result = migrateContent(kind, artifact.content, artifact.schemaVersion, locale);
+        const adapter = registry.get(artifact.format, locale);
+        const result = migrateContent(adapter, artifact.content, artifact.formatVersion, locale);
         return result.migrated
-            ? { ...artifact, content: result.content, schemaVersion: result.schemaVersion }
+            ? { ...artifact, content: result.content, formatVersion: result.formatVersion }
             : artifact;
     }
     function fields(artifact, scope, extra = {}) {
         return {
             artifactId: artifact.id,
-            kind: artifact.kind,
+            format: artifact.format,
             version: artifact.version,
             actorType: scope.actor.type,
             ...extra,
@@ -83,154 +75,36 @@ export function createArtifactService(options) {
             details: { expiresAt: lock.expiresAt },
         });
     }
-    async function replay(scope, id, key) {
-        if (!key)
-            return undefined;
-        const entry = await store.findByIdempotencyKey(scope, id, key);
-        if (!entry)
-            return undefined;
-        const artifact = await load(scope, id, entry.version);
-        const kind = registry.get(artifact.kind, locale);
-        return {
-            artifact,
-            version: entry.version,
-            createdIds: entry.createdIds,
-            diff: entry.diff,
-            lint: kind.lint(artifact.content, {
-                locale: artifact.locale,
-                theme: registry.theme(artifact.themeId, locale),
-            }),
-            rebased: false,
-            replayed: true,
-        };
-    }
-    /** Applies on the current version, rebasing from an older base when the touched items did not change. */
-    async function computeBatch(scope, current, request) {
-        if (request.baseVersion === current.version) {
-            return { result: applyOperations(registry, current, request.operations, { locale }), rebased: false };
-        }
-        const conflict = (changes) => {
-            metrics.conflict?.(fields(current, scope));
-            events.emit({
-                type: 'artifact.conflict',
-                artifactId: current.id,
-                baseVersion: request.baseVersion,
-                currentVersion: current.version,
-                actor: scope.actor,
-            });
-            return new ArtifactError('VERSION_CONFLICT', t(locale, 'VERSION_CONFLICT', { baseVersion: request.baseVersion, currentVersion: current.version }), {
-                issues: [
-                    {
-                        path: 'baseVersion',
-                        message: t(locale, 'VERSION_CONFLICT', {
-                            baseVersion: request.baseVersion,
-                            currentVersion: current.version,
-                        }),
-                        hint: t(locale, 'VERSION_CONFLICT_HINT'),
-                    },
-                ],
-                details: { currentVersion: current.version, changesSinceBase: changes },
-            });
-        };
-        if (request.baseVersion > current.version || request.baseVersion < 1)
-            throw conflict([]);
-        const base = await load(scope, current.id, request.baseVersion);
-        const kind = registry.get(current.kind, locale);
-        // Validate against the base first: an invalid batch is the model's error, not a conflict.
-        const onBase = applyOperations(registry, base, request.operations, { locale });
-        const changedSince = [
-            ...(base.title !== current.title
-                ? [
-                    {
-                        type: 'changed',
-                        target: 'envelope:title',
-                        summary: `'${base.title}' → '${current.title}'`,
-                    },
-                ]
-                : []),
-            ...(base.themeId !== current.themeId
-                ? [
-                    {
-                        type: 'changed',
-                        target: 'envelope:themeId',
-                        summary: `${base.themeId} → ${current.themeId}`,
-                    },
-                ]
-                : []),
-            ...(base.locale !== current.locale
-                ? [
-                    {
-                        type: 'changed',
-                        target: 'envelope:locale',
-                        summary: `${base.locale} → ${current.locale}`,
-                    },
-                ]
-                : []),
-            ...kind.diff(base.content, current.content, locale),
-        ];
-        const parsed = parseOperations(registry, current.kind, request.operations, locale);
-        const touched = batchTargets(kind, parsed, onBase.diff);
-        const changed = new Set(changedSince.map((change) => change.target));
-        if (targetsOverlap(touched, changed))
-            throw conflict(changedSince);
-        try {
-            return { result: applyOperations(registry, current, request.operations, { locale }), rebased: true };
-        }
-        catch (error) {
-            if (error instanceof ArtifactError &&
-                (error.code === 'OPERATION_FAILED' || error.code === 'INVALID_CONTENT')) {
-                throw conflict(changedSince);
-            }
-            throw error;
-        }
-    }
-    async function changeStatus(scope, id, to, action, message) {
-        const current = await load(scope, id);
-        await authorize(action, summarize(current), scope);
-        if (!canTransition(current.status, to)) {
-            throw new ArtifactError('PERMISSION_DENIED', t(locale, 'INVALID_STATUS_TRANSITION', { from: current.status, to }), {
-                details: { from: current.status, to },
-            });
-        }
-        const updated = await store.setStatus(scope, id, to, scope.actor, message);
+    /** The batch must be computed against the current version; a stale base is a conflict, never a silent rebase. */
+    function assertBase(scope, current, baseVersion) {
+        if (baseVersion === current.version)
+            return;
+        metrics.conflict?.(fields(current, scope));
         events.emit({
-            type: 'artifact.status_changed',
-            artifact: summarize(updated),
-            from: current.status,
-            to,
+            type: 'artifact.conflict',
+            artifactId: current.id,
+            baseVersion,
+            currentVersion: current.version,
             actor: scope.actor,
-            ...(message ? { message } : {}),
         });
-        logger.info('artifact.status_changed', fields(updated, scope, { from: current.status, to }));
-        return updated;
+        const message = t(locale, 'VERSION_CONFLICT', { baseVersion, currentVersion: current.version });
+        throw new ArtifactError('VERSION_CONFLICT', message, {
+            issues: [
+                {
+                    path: 'baseVersion',
+                    message,
+                    hint: t(locale, 'VERSION_CONFLICT_HINT'),
+                },
+            ],
+            details: { currentVersion: current.version },
+        });
     }
     const service = {
         registry,
         events,
         async create(scope, request) {
             await authorize('create', null, scope);
-            const kind = registry.get(request.kind, locale);
-            if (request.idempotencyKey && store.findCreatedByIdempotencyKey) {
-                const existing = await store.findCreatedByIdempotencyKey(scope, request.idempotencyKey);
-                if (existing) {
-                    const first = await load(scope, existing.id, 1);
-                    const prepared = [...registry.get(first.kind, locale).ids(first.content)];
-                    return {
-                        artifact: first,
-                        version: 1,
-                        createdIds: prepared,
-                        diff: [
-                            { type: 'added', target: `artifact:${first.id}`, summary: `${kind.label} "${first.title}"` },
-                        ],
-                        lint: kind.lint(first.content, {
-                            locale: first.locale,
-                            theme: registry.theme(first.themeId, locale),
-                        }),
-                        rebased: false,
-                        replayed: true,
-                    };
-                }
-            }
+            const adapter = registry.get(request.format, locale);
             const title = titleSchema.safeParse(sanitizeDeep(request.title));
             if (!title.success) {
                 throw new ArtifactError('INVALID_CONTENT', t(locale, 'INVALID_CONTENT'), {
@@ -240,295 +114,148 @@ export function createArtifactService(options) {
             const artifactLocale = request.locale ?? options.defaultArtifactLocale ?? 'en';
             const themeId = request.themeId ?? options.defaultThemeId ?? 'default';
             registry.theme(themeId, locale);
-            let raw;
-            const inputNotes = [];
-            if (request.input) {
-                const input = kind.inputs?.[request.input.format];
-                if (!input) {
-                    const available = Object.keys(kind.inputs ?? {});
-                    throw new ArtifactError('INVALID_CONTENT', t(locale, 'INPUT_FORMAT_UNSUPPORTED', { kind: kind.kind, format: request.input.format }), {
-                        issues: [
-                            {
-                                path: 'input.format',
-                                message: t(locale, 'INPUT_FORMAT_UNSUPPORTED', {
-                                    kind: kind.kind,
-                                    format: request.input.format,
-                                }),
-                                hint: t(locale, 'INPUT_FORMAT_HINT', { available: available.join(', ') || '—' }),
-                            },
-                        ],
-                    });
-                }
-                const parsedInput = input.schema.safeParse(sanitizeDeep(request.input.source));
-                if (!parsedInput.success) {
-                    throw new ArtifactError('INVALID_CONTENT', t(locale, 'INVALID_CONTENT'), {
-                        issues: zodIssuesToErrorIssues(parsedInput.error.issues, locale, 'input.source'),
-                    });
-                }
-                raw = input.toContent(parsedInput.data, {
-                    locale: artifactLocale,
-                    note: (message) => inputNotes.push(message),
-                });
-            }
-            else {
-                raw = request.content ?? kind.empty();
-            }
-            const prepared = prepareContent(registry, kind.kind, raw, { locale, theme: themeId });
-            prepared.lint.push(...inputNotes.map((message) => ({
-                code: 'input-note',
-                severity: 'info',
-                target: `input:${request.input?.format ?? 'content'}`,
-                message,
-            })));
+            const base = {
+                id: '',
+                format: adapter.format,
+                formatVersion: adapter.formatVersion,
+                version: 1,
+                title: title.data,
+                locale: artifactLocale,
+                themeId,
+                content: request.content ?? adapter.empty(),
+            };
+            // Creation with an initial batch goes through the same pipeline as any edit.
+            const applied = request.operations?.length
+                ? await applyOperations(registry, base, request.operations, { locale })
+                : undefined;
+            const prepared = applied
+                ? { content: applied.content, lint: applied.lint }
+                : prepareContent(registry, request.format, base.content, { locale: artifactLocale, themeId });
             const artifact = await store.create(scope, {
-                kind: kind.kind,
-                schemaVersion: kind.version,
+                format: adapter.format,
+                formatVersion: adapter.formatVersion,
                 title: title.data,
-                status: 'draft',
                 locale: artifactLocale,
                 themeId,
                 content: prepared.content,
-                createdIds: prepared.ids,
                 ...(request.tags ? { tags: request.tags } : {}),
-                ...(request.message ? { message: request.message } : {}),
-                ...(request.idempotencyKey ? { idempotencyKey: request.idempotencyKey } : {}),
             });
             events.emit({ type: 'artifact.created', artifact: summarize(artifact), actor: scope.actor });
-            if (prepared.lint.length > 0)
+            if (prepared.lint.length > 0) {
                 events.emit({
                     type: 'artifact.lint',
                     artifactId: artifact.id,
                     version: artifact.version,
                     warnings: prepared.lint.length,
                 });
+            }
             logger.info('artifact.created', fields(artifact, scope));
             return {
                 artifact,
                 version: artifact.version,
-                createdIds: prepared.ids,
+                createdRefs: applied?.createdRefs ?? [],
                 diff: [
-                    { type: 'added', target: `artifact:${artifact.id}`, summary: `${kind.label} "${artifact.title}"` },
+                    {
+                        type: 'added',
+                        target: `artifact:${artifact.id}`,
+                        summary: `${adapter.label} "${artifact.title}"`,
+                    },
                 ],
                 lint: prepared.lint,
-                rebased: false,
-                replayed: false,
             };
         },
-        async get(scope, id, opts) {
-            const artifact = await load(scope, id, opts?.version);
+        async get(scope, id) {
+            const artifact = await load(scope, id);
             await authorize('read', summarize(artifact), scope);
             return artifact;
         },
         async read(scope, id, opts = {}) {
-            const artifact = await load(scope, id, opts.version);
+            const artifact = await load(scope, id);
             await authorize('read', summarize(artifact), scope);
-            const kind = registry.get(artifact.kind, locale);
-            const projection = kind.project(artifact.content, {
+            const adapter = registry.get(artifact.format, locale);
+            const result = adapter.read(artifact.content, {
                 mode: opts.mode ?? 'outline',
                 locale: artifact.locale,
-                theme: registry.theme(artifact.themeId, locale),
                 ...(opts.range === undefined ? {} : { range: opts.range }),
                 ...(opts.maxTokens === undefined ? {} : { maxTokens: opts.maxTokens }),
                 ...(opts.cursor === undefined ? {} : { cursor: opts.cursor }),
                 ...(opts.charsPerToken === undefined ? {} : { charsPerToken: opts.charsPerToken }),
             });
-            const header = `${kind.label} "${artifact.title}" (id: ${artifact.id}, kind: ${artifact.kind}, version: ${artifact.version}, status: ${artifact.status}, locale: ${artifact.locale})`;
+            const projection = {
+                text: result.text,
+                truncated: result.truncated,
+                ...(result.cursor === undefined ? {} : { cursor: result.cursor }),
+            };
+            const header = `${adapter.label} "${artifact.title}" (id: ${artifact.id}, format: ${artifact.format}, version: ${artifact.version}, locale: ${artifact.locale})`;
             let text = `${header}\n${delimitProjection(artifact.id, projection.text)}`;
             if (projection.truncated) {
-                text += `\n[truncated — continue with cursor "${projection.cursor}"]\nRemaining outline:\n${projection.remainingOutline ?? ''}`;
+                text += `\n[truncated — continue with cursor "${projection.cursor}"]`;
             }
             return { artifact: summarize(artifact), version: artifact.version, projection, text };
         },
         async apply(scope, request) {
             const started = Date.now();
-            let current = await load(scope, request.artifactId);
+            const current = await load(scope, request.artifactId);
             await authorize('apply', summarize(current), scope);
-            const replayed = await replay(scope, current.id, request.idempotencyKey);
-            if (replayed)
-                return replayed;
             await assertNotLocked(scope, current.id);
-            if (current.status === 'published' &&
-                policy.requireApprovalToEditPublished &&
-                scope.actor.type === 'agent') {
-                throw new ArtifactError('APPROVAL_REQUIRED', t(locale, 'APPROVAL_REQUIRED', { action: 'apply' }), {
-                    issues: [
-                        {
-                            path: 'artifactId',
-                            message: t(locale, 'APPROVAL_REQUIRED', { action: 'apply' }),
-                            hint: t(locale, 'APPROVAL_REQUIRED_HINT'),
-                        },
-                    ],
+            assertBase(scope, current, request.baseVersion);
+            const result = await applyOperations(registry, current, request.operations, { locale });
+            let committed;
+            try {
+                committed = await store.commit(scope, current.id, {
+                    baseVersion: current.version,
+                    formatVersion: result.formatVersion,
+                    content: result.content,
+                    title: result.title,
+                    locale: result.locale,
+                    themeId: result.themeId,
                 });
             }
-            for (let attempt = 0;; attempt++) {
-                const { result, rebased } = await computeBatch(scope, current, request);
-                try {
-                    const committed = await store.commit(scope, current.id, {
-                        baseVersion: current.version,
-                        schemaVersion: result.schemaVersion,
-                        content: result.content,
-                        title: result.title,
-                        locale: result.locale,
-                        themeId: result.themeId,
-                        // Editing a published (or pending) artifact starts a new draft (spec §15.3).
-                        ...(current.status === 'published' || current.status === 'pending_approval'
-                            ? { status: 'draft' }
-                            : {}),
-                        operations: request.operations,
-                        diff: result.diff,
-                        createdIds: result.createdIds,
-                        ...(request.message ? { message: request.message } : {}),
-                        ...(request.idempotencyKey ? { idempotencyKey: request.idempotencyKey } : {}),
-                    });
-                    const duration = Date.now() - started;
-                    const logFields = fields(committed, scope, {
-                        operationCount: request.operations.length,
-                        durationMs: duration,
-                    });
-                    metrics.applyDuration?.(duration, logFields);
-                    logger.info('artifact.committed', logFields);
-                    events.emit({
-                        type: 'artifact.committed',
-                        artifact: summarize(committed),
-                        actor: scope.actor,
-                        operationCount: request.operations.length,
-                        diff: result.diff,
-                        rebased,
-                    });
-                    if (result.lint.length > 0)
-                        events.emit({
-                            type: 'artifact.lint',
-                            artifactId: committed.id,
-                            version: committed.version,
-                            warnings: result.lint.length,
-                        });
-                    return {
-                        artifact: committed,
-                        version: committed.version,
-                        createdIds: result.createdIds,
-                        diff: result.diff,
-                        lint: result.lint,
-                        rebased,
-                        replayed: false,
-                    };
-                }
-                catch (error) {
-                    // Another writer won the race: reload and rebase from the original base.
-                    if (error instanceof ArtifactError && error.code === 'VERSION_CONFLICT' && attempt < retries) {
-                        current = await load(scope, request.artifactId);
-                        continue;
-                    }
-                    if (error instanceof ArtifactError)
-                        metrics.rejection?.(error.code, fields(current, scope));
-                    throw error;
-                }
+            catch (error) {
+                if (error instanceof ArtifactError)
+                    metrics.rejection?.(error.code, fields(current, scope));
+                throw error;
             }
-        },
-        async preview(scope, request) {
-            const current = await load(scope, request.artifactId);
-            await authorize('read', summarize(current), scope);
-            return (await computeBatch(scope, current, request)).result;
-        },
-        async list(scope, filter = {}, page = {}) {
-            await authorize('list', null, scope);
-            return store.list(scope, filter, page);
-        },
-        async history(scope, id, page = {}) {
-            const current = await load(scope, id);
-            await authorize('history', summarize(current), scope);
-            return store.history(scope, id, page);
-        },
-        async restore(scope, id, version, message) {
-            const current = await load(scope, id);
-            await authorize('restore', summarize(current), scope);
-            await assertNotLocked(scope, id);
-            const old = await load(scope, id, version);
-            const kind = registry.get(current.kind, locale);
-            const diff = [
-                ...(old.title !== current.title
-                    ? [
-                        {
-                            type: 'changed',
-                            target: 'envelope:title',
-                            summary: `'${current.title}' → '${old.title}'`,
-                        },
-                    ]
-                    : []),
-                ...kind.diff(current.content, old.content, locale),
-            ];
-            const beforeIds = new Set(kind.ids(current.content));
-            const createdIds = [...kind.ids(old.content)].filter((itemId) => !beforeIds.has(itemId));
-            const committed = await store.commit(scope, id, {
-                baseVersion: current.version,
-                schemaVersion: old.schemaVersion,
-                content: old.content,
-                title: old.title,
-                locale: old.locale,
-                themeId: old.themeId,
-                ...(current.status !== 'draft' && current.status !== 'archived' ? { status: 'draft' } : {}),
-                operations: [{ op: 'replace_content', content: '[restored]' }],
-                diff,
-                createdIds,
-                restoredFrom: version,
-                message: message ?? `Restored version ${version}`,
+            const duration = Date.now() - started;
+            const logFields = fields(committed, scope, {
+                operationCount: request.operations.length,
+                durationMs: duration,
             });
+            metrics.applyDuration?.(duration, logFields);
+            logger.info('artifact.committed', logFields);
             events.emit({
                 type: 'artifact.committed',
                 artifact: summarize(committed),
                 actor: scope.actor,
-                operationCount: 0,
-                diff,
-                rebased: false,
+                operationCount: request.operations.length,
+                diff: result.diff,
             });
+            if (result.lint.length > 0) {
+                events.emit({
+                    type: 'artifact.lint',
+                    artifactId: committed.id,
+                    version: committed.version,
+                    warnings: result.lint.length,
+                });
+            }
             return {
                 artifact: committed,
                 version: committed.version,
-                createdIds,
-                diff,
-                lint: kind.lint(committed.content, {
-                    locale: committed.locale,
-                    theme: registry.theme(committed.themeId, locale),
-                }),
-                rebased: false,
-                replayed: false,
+                createdRefs: result.createdRefs,
+                diff: result.diff,
+                lint: result.lint,
             };
         },
-        submit: (scope, id, message) => changeStatus(scope, id, 'pending_approval', 'submit', message),
-        async approve(scope, id, message) {
-            if (scope.actor.type === 'agent') {
-                throw new ArtifactError('PERMISSION_DENIED', t(locale, 'PERMISSION_DENIED', { action: 'approve' }));
-            }
-            const current = await load(scope, id);
-            if (current.status !== 'pending_approval') {
-                throw new ArtifactError('PERMISSION_DENIED', t(locale, 'INVALID_STATUS_TRANSITION', { from: current.status, to: 'published' }));
-            }
-            return changeStatus(scope, id, 'published', 'approve', message);
-        },
-        async reject(scope, id, reason) {
-            if (scope.actor.type === 'agent') {
-                throw new ArtifactError('PERMISSION_DENIED', t(locale, 'PERMISSION_DENIED', { action: 'reject' }));
-            }
-            const current = await load(scope, id);
-            if (current.status !== 'pending_approval') {
-                throw new ArtifactError('PERMISSION_DENIED', t(locale, 'INVALID_STATUS_TRANSITION', { from: current.status, to: 'draft' }));
-            }
-            return changeStatus(scope, id, 'draft', 'reject', reason);
+        async preview(scope, request) {
+            const current = await load(scope, request.artifactId);
+            await authorize('read', summarize(current), scope);
+            assertBase(scope, current, request.baseVersion);
+            return applyOperations(registry, current, request.operations, { locale });
         },
-        async publish(scope, id) {
-            if (policy.requireApprovalToPublish) {
-                throw new ArtifactError('APPROVAL_REQUIRED', t(locale, 'APPROVAL_REQUIRED', { action: 'publish' }), {
-                    issues: [
-                        {
-                            path: 'id',
-                            message: t(locale, 'APPROVAL_REQUIRED', { action: 'publish' }),
-                            hint: t(locale, 'APPROVAL_REQUIRED_HINT'),
-                        },
-                    ],
-                });
-            }
-            return changeStatus(scope, id, 'published', 'publish');
+        async list(scope, filter = {}, page = {}) {
+            await authorize('list', null, scope);
+            return store.list(scope, filter, page);
         },
-        archive: (scope, id) => changeStatus(scope, id, 'archived', 'archive'),
         async lock(scope, id, ttlMs = 5 * 60_000) {
             const current = await load(scope, id);
             await authorize('lock', summarize(current), scope);
@@ -542,20 +269,9 @@ export function createArtifactService(options) {
         },
         async export(scope, request) {
             const started = Date.now();
-            const artifact = await load(scope, request.artifactId, request.version);
+            const artifact = await load(scope, request.artifactId);
             await authorize('export', summarize(artifact), scope);
-            if (policy.requireApprovalToExport && artifact.status !== 'published') {
-                throw new ArtifactError('APPROVAL_REQUIRED', t(locale, 'APPROVAL_REQUIRED', { action: 'export' }), {
-                    issues: [
-                        {
-                            path: 'artifactId',
-                            message: t(locale, 'APPROVAL_REQUIRED', { action: 'export' }),
-                            hint: t(locale, 'APPROVAL_REQUIRED_HINT'),
-                        },
-                    ],
-                });
-            }
-            const exporter = registry.exporter(artifact.kind, request.format, locale);
+            const exporter = registry.exporter(artifact.format, request.format, locale);
             const warnings = [];
             const timeout = AbortSignal.timeout(request.timeoutMs ?? options.exportTimeoutMs ?? 60_000);
             const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
@@ -573,8 +289,8 @@ export function createArtifactService(options) {
                 }), signal);
             }
             catch (cause) {
-                metrics.rejection?.('EXPORT_FAILED', fields(artifact, scope, { format: request.format }));
-                logger.error('artifact.export_failed', fields(artifact, scope, { format: request.format }));
+                metrics.rejection?.('EXPORT_FAILED', fields(artifact, scope, { target: request.format }));
+                logger.error('artifact.export_failed', fields(artifact, scope, { target: request.format }));
                 throw new ArtifactError('EXPORT_FAILED', t(locale, 'EXPORT_FAILED', { format: request.format }), {
                     cause,
                 });
@@ -601,7 +317,7 @@ export function createArtifactService(options) {
                 result.asset = { ref: stored.ref, size: stored.size, hash: stored.hash };
             }
             const duration = Date.now() - started;
-            metrics.exportDuration?.(duration, fields(artifact, scope, { format: request.format, durationMs: duration }));
+            metrics.exportDuration?.(duration, fields(artifact, scope, { target: request.format, durationMs: duration }));
             events.emit({
                 type: 'artifact.exported',
                 artifact: summarize(artifact),
@@ -648,5 +364,4 @@ export function slugify(title) {
         .slice(0, 80);
     return slug || 'artifact';
 }
-export { deepEqual, envelopeOperationSchema };
 //# sourceMappingURL=service.js.map