@opengeni/core 0.21.2 → 0.24.1

package/dist/domain/durable-learning-slack-publication.d.ts

@@ -0,0 +1,72 @@
+import { type Database, type EnqueueMemorySlackPublicationResult } from "@opengeni/db";
+/**
+ * Narrow post-persistence port for the immutable durable-learning v1 attempt/receipt contract.
+ * The router owns validation, authority, routing, and persistence. This adapter
+ * consumes only the fields required to create a bounded notification projection.
+ */
+export type DurableLearningSlackOutcome = {
+    attempt: {
+        id: string;
+        accountId: string;
+        workspaceId: string;
+        inputHash: string;
+        actor: {
+            kind: "human" | "agent" | "service";
+            subjectId: string;
+        };
+        initiatingHumanSubjectId: string | null;
+        sessionId: string | null;
+        request: {
+            operation: "write";
+            subject: {
+                kind: string;
+                summary: string | null;
+            };
+            evidence: Array<{
+                kind: string;
+            }>;
+        } | {
+            operation: "rollback";
+            targetAttemptId: string;
+        };
+    };
+    receipt: {
+        attemptId: string;
+        inputHash: string;
+        outcome: "applied" | "proposed" | "evidence_recorded" | "noop" | "clarification_required" | "rejected" | "rolled_back" | "failed";
+        decision: {
+            code: string;
+            destination: string | null;
+            scope: {
+                kind: string;
+            } | null;
+            authority: string | null;
+        };
+        resource: {
+            surface: string;
+            id: string;
+            version: string | null;
+            status: string;
+        } | null;
+        createdAt: string;
+    };
+};
+export type DurableLearningSlackPublicationResult = {
+    kind: "contract_mismatch" | "not_workspace_scoped" | "connector_evidence_untrusted" | "summary_required" | "policy_quiet";
+    enqueue: null;
+} | {
+    kind: "enqueued";
+    enqueue: EnqueueMemorySlackPublicationResult;
+};
+export type DurableLearningSlackProjection = {
+    summary: string;
+    outcome: DurableLearningSlackOutcome["receipt"]["outcome"];
+    decisionCode: string;
+    destination: string | null;
+    authority: string | null;
+    resource: DurableLearningSlackOutcome["receipt"]["resource"];
+    occurredAt: string;
+};
+export declare function publishDurableLearningOutcomeToSlack(db: Database, outcome: DurableLearningSlackOutcome): Promise<DurableLearningSlackPublicationResult>;
+export declare function durableLearningImportance(outcome: DurableLearningSlackOutcome): "major" | "normal" | "minor";
+export declare function durableLearningSlackProjection(outcome: DurableLearningSlackOutcome): DurableLearningSlackProjection | null;

package/dist/domain/editable-artifacts/agent-application.d.ts

@@ -0,0 +1,192 @@
+import { type DocumentArtifactCommand, type DocumentArtifactQuery, type PresentationArtifactCommand, type PresentationArtifactQuery, type SpreadsheetArtifactCommand, type SpreadsheetArtifactKernelQuery } from "@opengeni/contracts/editable-artifacts";
+import type { EditableArtifactDurableExportService, EditableArtifactMaterializationFormat, EditableArtifactMaterializationJob } from "./durable-export.js";
+import type { EditableArtifactService } from "./service.js";
+import { type EditableArtifact, type EditableArtifactActor, type EditableArtifactClientTransactionId, type EditableArtifactId, type EditableArtifactModality, type EditableArtifactOriginalImport, type EditableArtifactScope, type ImportEditableArtifactRequest } from "./types.js";
+import type { EditableArtifactKernelState } from "./ports.js";
+export type EditableArtifactAgentCommandBatch = Readonly<{
+    modality: "spreadsheet";
+    commands: readonly SpreadsheetArtifactCommand[];
+}> | Readonly<{
+    modality: "document";
+    commands: readonly DocumentArtifactCommand[];
+}> | Readonly<{
+    modality: "presentation";
+    commands: readonly PresentationArtifactCommand[];
+}>;
+export type EditableArtifactAgentQuery = Readonly<{
+    modality: "spreadsheet";
+    query: SpreadsheetArtifactKernelQuery;
+}> | Readonly<{
+    modality: "document";
+    query: DocumentArtifactQuery;
+}> | Readonly<{
+    modality: "presentation";
+    query: PresentationArtifactQuery;
+}>;
+export type EditableArtifactAgentContext = Readonly<{
+    scope: EditableArtifactScope;
+    actor: EditableArtifactActor;
+    sessionId: string;
+}>;
+export type EditableArtifactAgentMetadata = Readonly<{
+    id: string;
+    modality: EditableArtifactModality;
+    title: string;
+    lifecycle: EditableArtifact["lifecycle"];
+    headSequence: number;
+    stateHash: string;
+    createdAt: string;
+    updatedAt: string;
+}>;
+export type EditableArtifactAgentMutationReceipt = Readonly<{
+    artifact: EditableArtifactAgentMetadata;
+    transaction: Readonly<{
+        id: string;
+        clientTransactionId: string;
+        sequenceStart: number;
+        sequenceEnd: number;
+        stateHash: string;
+        committedAt: string;
+        replayed: boolean;
+    }>;
+}>;
+export type EditableArtifactAgentExportReceipt = Readonly<{
+    fileId: string;
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256: string;
+    artifactId: string;
+    versionId: string;
+    materializationJobId: string;
+    sourceHeadSequence: number;
+    sourceStateHash: string;
+}>;
+export type PreparedEditableArtifactImport = Readonly<{
+    originalImport: EditableArtifactOriginalImport;
+    snapshot: ImportEditableArtifactRequest["snapshot"];
+}>;
+export type EditableArtifactOfficeImportErrorCode = "invalid_source" | "source_changed" | "unsupported_content";
+export declare class EditableArtifactOfficeImportError extends Error {
+    readonly code: EditableArtifactOfficeImportErrorCode;
+    constructor(code: EditableArtifactOfficeImportErrorCode);
+}
+export interface EditableArtifactAgentAssociationPort {
+    listArtifactIds(input: {
+        scope: EditableArtifactScope;
+        sessionId: string;
+        limit: number;
+    }): Promise<readonly EditableArtifactId[]>;
+    touch(input: {
+        scope: EditableArtifactScope;
+        sessionId: string;
+        artifactId: EditableArtifactId;
+    }): Promise<void>;
+}
+export interface EditableArtifactAgentInspectionKernelPort {
+    query(input: {
+        state: EditableArtifactKernelState;
+        queryBytes: Uint8Array;
+    }): Promise<Uint8Array>;
+}
+export interface EditableArtifactOfficeImportPort {
+    prepare(input: {
+        scope: EditableArtifactScope;
+        actor: EditableArtifactActor;
+        fileId: string;
+        modality: EditableArtifactModality;
+        signal?: AbortSignal;
+    }): Promise<PreparedEditableArtifactImport>;
+}
+export interface EditableArtifactAgentWorkspaceFilePort {
+    ensureMaterializationFile(input: {
+        scope: EditableArtifactScope;
+        actor: EditableArtifactActor;
+        artifact: EditableArtifact;
+        versionId: string;
+        jobId: string;
+        filename: string;
+        sourceHeadSequence: number;
+        sourceStateHash: string;
+        signal?: AbortSignal;
+    }): Promise<EditableArtifactAgentExportReceipt>;
+}
+export type EditableArtifactAgentApplicationDependencies = Readonly<{
+    domain: EditableArtifactService;
+    exports: EditableArtifactDurableExportService;
+    associations: EditableArtifactAgentAssociationPort;
+    inspector: EditableArtifactAgentInspectionKernelPort;
+    officeImports: EditableArtifactOfficeImportPort;
+    workspaceFiles: EditableArtifactAgentWorkspaceFilePort;
+}>;
+/**
+ * Attempt-neutral use cases shared by direct model tools and Codemode. This is
+ * not another artifact engine: every mutation terminates at EditableArtifactService.
+ */
+export declare class EditableArtifactAgentApplication {
+    private readonly dependencies;
+    constructor(dependencies: EditableArtifactAgentApplicationDependencies);
+    list(input: EditableArtifactAgentContext & Readonly<{
+        limit?: number;
+    }>): Promise<readonly EditableArtifactAgentMetadata[]>;
+    create(input: EditableArtifactAgentContext & Readonly<{
+        idempotencyKey: EditableArtifactClientTransactionId;
+        modality: EditableArtifactModality;
+        title: string;
+        signal?: AbortSignal;
+    }>): Promise<EditableArtifactAgentMetadata>;
+    import(input: EditableArtifactAgentContext & Readonly<{
+        idempotencyKey: EditableArtifactClientTransactionId;
+        fileId: string;
+        modality: EditableArtifactModality;
+        title: string;
+        signal?: AbortSignal;
+    }>): Promise<EditableArtifactAgentMetadata>;
+    get(input: EditableArtifactAgentContext & Readonly<{
+        artifactId: EditableArtifactId;
+    }>): Promise<EditableArtifactAgentMetadata>;
+    inspect(input: EditableArtifactAgentContext & Readonly<{
+        artifactId: EditableArtifactId;
+        request: EditableArtifactAgentQuery;
+    }>): Promise<Readonly<{
+        artifact: EditableArtifactAgentMetadata;
+        projection: unknown;
+    }>>;
+    apply(input: EditableArtifactAgentContext & Readonly<{
+        artifactId: EditableArtifactId;
+        clientTransactionId: EditableArtifactClientTransactionId;
+        expectedHeadSequence: number;
+        expectedStateHash: string;
+        batch: EditableArtifactAgentCommandBatch;
+    }>): Promise<EditableArtifactAgentMutationReceipt>;
+    startExport(input: EditableArtifactAgentContext & Readonly<{
+        artifactId: EditableArtifactId;
+        idempotencyKey: string;
+        format: EditableArtifactMaterializationFormat;
+        options?: Readonly<Record<string, unknown>>;
+        signal?: AbortSignal;
+    }>): Promise<Readonly<{
+        artifact: EditableArtifactAgentMetadata;
+        versionId: string;
+        jobId: string;
+        sourceHeadSequence: number;
+        sourceStateHash: string;
+        state: EditableArtifactMaterializationJob["state"];
+    }>>;
+    exportStatus(input: EditableArtifactAgentContext & Readonly<{
+        artifactId: EditableArtifactId;
+        versionId: string;
+        jobId: string;
+        signal?: AbortSignal;
+    }>): Promise<Readonly<{
+        artifact: EditableArtifactAgentMetadata;
+        versionId: string;
+        jobId: string;
+        sourceHeadSequence: number;
+        sourceStateHash: string;
+        state: EditableArtifactMaterializationJob["state"];
+        errorCode: string | null;
+        file: EditableArtifactAgentExportReceipt | null;
+    }>>;
+    private touch;
+}

package/dist/domain/editable-artifacts/durable-export-postgres.d.ts

@@ -0,0 +1,4 @@
+import { type PostgresEditableArtifactDurableExportStore } from "@opengeni/db/editable-artifact-durable-export";
+import { type EditableArtifactDurableExportStorePort } from "./durable-export.js";
+/** One-way adapter keeps @opengeni/db free of the core package cycle. */
+export declare function editableArtifactDurableExportStorePortFromPostgres(store: PostgresEditableArtifactDurableExportStore): EditableArtifactDurableExportStorePort;

package/dist/domain/editable-artifacts/durable-export.d.ts

@@ -0,0 +1,212 @@
+import type { BoundedObjectReadPort } from "@opengeni/storage";
+import type { EditableArtifactAuthorizationPort } from "./ports.js";
+import { type EditableArtifactActor, type EditableArtifactCausalFrontier, type EditableArtifactContentHash, type EditableArtifactId, type EditableArtifactModality, type EditableArtifactScope, type EditableArtifactSnapshotMetadata, type EditableArtifactStateHash } from "./types.js";
+export declare const EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES: number;
+export declare const EDITABLE_ARTIFACT_EXPORT_MAX_OPTIONS_BYTES: number;
+export type EditableArtifactMaterializationFormat = "xlsx" | "pptx" | "docx" | "pdf" | "png" | "webp";
+export type EditableArtifactMaterializationMimeType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/pdf" | "image/png" | "image/webp";
+export type EditableArtifactPinnedVersion = Readonly<{
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    id: string;
+    modality: EditableArtifactModality;
+    snapshotId: string;
+    headSequence: number;
+    causalFrontier: EditableArtifactCausalFrontier | null;
+    nativeRevision: number | null;
+    stateHash: EditableArtifactStateHash;
+    name: string;
+    pinned: true;
+    createdBySubjectId: string;
+    createdAt: string;
+}>;
+export type EditableArtifactMaterializationResult = Readonly<{
+    id: string;
+    byteSize: number;
+    contentHash: EditableArtifactContentHash;
+    mimeType: EditableArtifactMaterializationMimeType;
+    verifiedAt: string;
+    createdAt: string;
+}>;
+export type EditableArtifactMaterializationJob = Readonly<{
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    id: string;
+    versionId: string;
+    inputSnapshotId: string;
+    targetHeadSequence: number;
+    stateHash: EditableArtifactStateHash;
+    format: EditableArtifactMaterializationFormat;
+    state: "pending" | "running" | "succeeded" | "failed";
+    attemptCount: number;
+    errorCode: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    result: EditableArtifactMaterializationResult | null;
+}>;
+export type EditableArtifactMaterializationProfile = Readonly<{
+    modality: EditableArtifactModality;
+    format: EditableArtifactMaterializationFormat;
+    codecId: string;
+    codecVersion: string;
+    kernelVersion: string;
+    fontRegistryHash: string;
+    policyHash: string;
+    /** Canonical JSON object understood by the pinned native materializer. */
+    normalizedOptions: string;
+}>;
+/** Server-owned profile lookup. Clients never supply executable identity facts. */
+export interface EditableArtifactMaterializationProfilePort {
+    resolve(input: Readonly<{
+        modality: EditableArtifactModality;
+        format: EditableArtifactMaterializationFormat;
+        options: Readonly<Record<string, unknown>>;
+    }>): Promise<EditableArtifactMaterializationProfile | null>;
+}
+export interface EditableArtifactDurableExportIdFactoryPort {
+    next(kind: "version" | "materialization_job" | "receipt"): string;
+}
+export interface EditableArtifactExactSnapshotPort {
+    ensure(input: Readonly<{
+        scope: EditableArtifactScope;
+        artifactId: EditableArtifactId;
+        actor: EditableArtifactActor;
+        signal?: AbortSignal;
+    }>): Promise<EditableArtifactSnapshotMetadata>;
+}
+type DurableExportContext = Readonly<{
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    actor: EditableArtifactActor;
+}>;
+export type PinEditableArtifactVersionStoreRequest = DurableExportContext & Readonly<{
+    expectedAuthorizationRevision: number;
+    authorityKey: string;
+    receiptId: string;
+    versionId: string;
+    idempotencyKey: string;
+    requestHash: string;
+    name: string;
+    snapshot: EditableArtifactSnapshotMetadata;
+}>;
+export type PinEditableArtifactVersionStoreResult = Readonly<{
+    kind: "result";
+    version: EditableArtifactPinnedVersion;
+    replayed: boolean;
+}> | Readonly<{
+    kind: "authorization_stale";
+}>;
+export type EnqueueEditableArtifactMaterializationStoreRequest = DurableExportContext & Readonly<{
+    expectedAuthorizationRevision: number;
+    authorityKey: string;
+    receiptId: string;
+    jobId: string;
+    idempotencyKey: string;
+    requestHash: string;
+    versionId: string;
+    profile: EditableArtifactMaterializationProfile;
+}>;
+export type EnqueueEditableArtifactMaterializationStoreResult = Readonly<{
+    kind: "result";
+    job: EditableArtifactMaterializationJob;
+    replayed: boolean;
+}> | Readonly<{
+    kind: "authorization_stale";
+}>;
+export type ReadEditableArtifactMaterializationStoreResult = Readonly<{
+    kind: "result";
+    job: EditableArtifactMaterializationJob | null;
+}> | Readonly<{
+    kind: "authorization_stale";
+}>;
+export type ReadEditableArtifactVersionStoreResult = Readonly<{
+    kind: "result";
+    version: EditableArtifactPinnedVersion | null;
+}> | Readonly<{
+    kind: "authorization_stale";
+}>;
+export type ReadEditableArtifactMaterializationDownloadStoreResult = Readonly<{
+    kind: "result";
+    job: EditableArtifactMaterializationJob | null;
+    objectReference: string | null;
+}> | Readonly<{
+    kind: "authorization_stale";
+}>;
+export interface EditableArtifactDurableExportStorePort {
+    pinVersion(input: PinEditableArtifactVersionStoreRequest): Promise<PinEditableArtifactVersionStoreResult>;
+    enqueueMaterialization(input: EnqueueEditableArtifactMaterializationStoreRequest): Promise<EnqueueEditableArtifactMaterializationStoreResult>;
+    readVersion(input: DurableExportContext & Readonly<{
+        expectedAuthorizationRevision: number;
+        versionId: string;
+    }>): Promise<ReadEditableArtifactVersionStoreResult>;
+    readMaterialization(input: DurableExportContext & Readonly<{
+        expectedAuthorizationRevision: number;
+        jobId: string;
+    }>): Promise<ReadEditableArtifactMaterializationStoreResult>;
+    readMaterializationDownload(input: DurableExportContext & Readonly<{
+        expectedAuthorizationRevision: number;
+        jobId: string;
+    }>): Promise<ReadEditableArtifactMaterializationDownloadStoreResult>;
+}
+export type EditableArtifactMaterializationDownload = Readonly<{
+    artifactId: EditableArtifactId;
+    jobId: string;
+    format: EditableArtifactMaterializationFormat;
+    byteSize: number;
+    contentHash: EditableArtifactContentHash;
+    mimeType: EditableArtifactMaterializationMimeType;
+    chunks(input?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<Uint8Array>;
+    assertUnchanged(signal?: AbortSignal): Promise<void>;
+    close(): Promise<void>;
+}>;
+export type EditableArtifactDurableExportErrorCode = "invalid_request" | "not_found" | "forbidden" | "conflict" | "unsupported_format" | "not_ready" | "unavailable";
+export declare class EditableArtifactDurableExportError extends Error {
+    readonly code: EditableArtifactDurableExportErrorCode;
+    constructor(code: EditableArtifactDurableExportErrorCode);
+}
+export type EditableArtifactDurableExportServiceDependencies = Readonly<{
+    authorization: EditableArtifactAuthorizationPort;
+    exactSnapshots: EditableArtifactExactSnapshotPort;
+    store: EditableArtifactDurableExportStorePort;
+    ids: EditableArtifactDurableExportIdFactoryPort;
+    profiles: EditableArtifactMaterializationProfilePort;
+    materializationObjects: BoundedObjectReadPort;
+}>;
+export declare class EditableArtifactDurableExportService {
+    private readonly dependencies;
+    constructor(dependencies: EditableArtifactDurableExportServiceDependencies);
+    pinVersion(input: DurableExportContext & {
+        idempotencyKey: string;
+        name: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        version: EditableArtifactPinnedVersion;
+        replayed: boolean;
+    }>;
+    enqueueMaterialization(input: DurableExportContext & {
+        idempotencyKey: string;
+        versionId: string;
+        format: EditableArtifactMaterializationFormat;
+        options?: Readonly<Record<string, unknown>>;
+    }): Promise<{
+        job: EditableArtifactMaterializationJob;
+        replayed: boolean;
+    }>;
+    getMaterialization(input: DurableExportContext & Readonly<{
+        jobId: string;
+    }>): Promise<EditableArtifactMaterializationJob>;
+    openMaterializationDownload(input: DurableExportContext & Readonly<{
+        jobId: string;
+        signal?: AbortSignal;
+    }>): Promise<EditableArtifactMaterializationDownload>;
+    private getVersion;
+    private requireExportPermission;
+}
+export declare function editableArtifactMaterializationMimeType(format: EditableArtifactMaterializationFormat): EditableArtifactMaterializationMimeType;
+export declare function editableArtifactFormatMatchesModality(modality: EditableArtifactModality, format: EditableArtifactMaterializationFormat): boolean;
+export declare function validateEditableArtifactPinnedVersion(version: EditableArtifactPinnedVersion): EditableArtifactPinnedVersion;
+export declare function validateEditableArtifactMaterializationJob(job: EditableArtifactMaterializationJob): EditableArtifactMaterializationJob;
+export {};

package/dist/domain/editable-artifacts/errors.d.ts

@@ -0,0 +1,47 @@
+export type EditableArtifactDomainErrorCode = "invalid_request" | "not_found" | "forbidden" | "not_editable" | "idempotency_conflict" | "request_hash_mismatch" | "causal_future" | "causal_chain_conflict" | "stale_base" | "kernel_contract_violation" | "retryable_conflict" | "invalid_undo_target" | "snapshot_conflict" | "outbox_lease_conflict";
+export declare class EditableArtifactDomainError extends Error {
+    readonly code: EditableArtifactDomainErrorCode;
+    constructor(code: EditableArtifactDomainErrorCode, message: string);
+}
+export declare class EditableArtifactNotFoundError extends EditableArtifactDomainError {
+    constructor();
+}
+export declare class EditableArtifactInvalidRequestError extends EditableArtifactDomainError {
+    constructor(message: string);
+}
+export declare class EditableArtifactForbiddenError extends EditableArtifactDomainError {
+    constructor(permission: string);
+}
+export declare class EditableArtifactNotEditableError extends EditableArtifactDomainError {
+    constructor(state: string);
+}
+export declare class EditableArtifactIdempotencyConflictError extends EditableArtifactDomainError {
+    constructor();
+}
+export declare class EditableArtifactRequestHashMismatchError extends EditableArtifactDomainError {
+    constructor();
+}
+export declare class EditableArtifactCausalFutureError extends EditableArtifactDomainError {
+    constructor();
+}
+export declare class EditableArtifactCausalChainError extends EditableArtifactDomainError {
+    constructor(message: string);
+}
+export declare class EditableArtifactStaleBaseError extends EditableArtifactDomainError {
+    constructor();
+}
+export declare class EditableArtifactKernelContractError extends EditableArtifactDomainError {
+    constructor(message: string);
+}
+export declare class EditableArtifactRetryableConflictError extends EditableArtifactDomainError {
+    constructor();
+}
+export declare class EditableArtifactUndoTargetError extends EditableArtifactDomainError {
+    constructor(message: string);
+}
+export declare class EditableArtifactSnapshotConflictError extends EditableArtifactDomainError {
+    constructor(message: string);
+}
+export declare class EditableArtifactOutboxLeaseConflictError extends EditableArtifactDomainError {
+    constructor();
+}

package/dist/domain/editable-artifacts/hash.d.ts

@@ -0,0 +1,11 @@
+import type { EditableArtifactMutationIntentCodecPort } from "./ports.js";
+import { type CreateEditableArtifactRequest, type ImportEditableArtifactRequest, type EditableArtifactRequestHash } from "./types.js";
+/** Canonical identity of caller-controlled create semantics only. */
+export declare function hashEditableArtifactCreateRequest(request: Pick<CreateEditableArtifactRequest, "modality" | "title">): EditableArtifactRequestHash;
+/** Canonical identity of one retained Office import and its verified snapshot facts. */
+export declare function hashEditableArtifactImportRequest(request: Omit<ImportEditableArtifactRequest, "idempotencyKey">): EditableArtifactRequestHash;
+/** Production adapter over the one shared OGATX001 canonical wire codec. */
+export declare class OgatxEditableArtifactMutationIntentCodec implements EditableArtifactMutationIntentCodecPort {
+    decodeAndVerify(input: Parameters<EditableArtifactMutationIntentCodecPort["decodeAndVerify"]>[0]): ReturnType<EditableArtifactMutationIntentCodecPort["decodeAndVerify"]>;
+}
+export declare const ogatxEditableArtifactMutationIntentCodec: OgatxEditableArtifactMutationIntentCodec;

package/dist/domain/editable-artifacts/in-memory.d.ts

@@ -0,0 +1,99 @@
+import type { ClaimEditableArtifactLiveOutboxRequest, CreateEditableArtifactStoreRequest, CreateEditableArtifactStoreResult, EditableArtifactAuthorizationRevisionPort, EditableArtifactScopeAuthorizationRevisionPort, EditableArtifactClockPort, EditableArtifactKernelState, EditableArtifactStableIdFactoryPort, EditableArtifactStableIdKind, EditableArtifactStorePort, EditableArtifactTransactionBasis, EditableArtifactSnapshotUnitOfWorkPort, ReadEditableArtifactTransactionBasisRequest, ReadEditableArtifactAtAuthorizationRevisionResult, TryCommitAppliedEditableArtifactTransactionRequest, TryCommitAppliedEditableArtifactTransactionResult } from "./ports.js";
+import { type EditableArtifact, type CreateEditableArtifactResult, type EditableArtifactCommittedTransactionRecord, type EditableArtifactId, type EditableArtifactLifecycleState, type EditableArtifactLiveOutboxRecord, type EditableArtifactModality, type EditableArtifactOperationRecord, type EditableArtifactOutboxId, type EditableArtifactOutboxRetryFailureCode, type EditableArtifactOutboxDeadLetterFailureCode, type EditableArtifactReceipt, type EditableArtifactScope, type EditableArtifactSnapshotMetadata, type EditableArtifactStableId, type EditableArtifactStateHash } from "./types.js";
+export type SeedInMemoryEditableArtifact = Readonly<{
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    title: string;
+    stateHash: EditableArtifactStateHash;
+    lifecycle?: EditableArtifactLifecycleState;
+    authorizationRevision?: number;
+    /** Authoritative native revision for a pre-existing serialized artifact. */
+    nativeRevision?: number;
+    createdAt?: string;
+}>;
+/**
+ * Executable correctness reference for tests. It deliberately serializes and
+ * copies aggregate history; production runtimes must use the PostgreSQL CAS
+ * adapter rather than treating this O(history) store as a performance model.
+ */
+export declare class InMemoryEditableArtifactStore implements EditableArtifactStorePort, EditableArtifactAuthorizationRevisionPort, EditableArtifactScopeAuthorizationRevisionPort {
+    private readonly now;
+    private aggregates;
+    private creationReceipts;
+    private scopeCreateAuthorizationRevisions;
+    private exclusiveTail;
+    constructor(now?: () => Date);
+    findArtifactCreation(scopeInput: EditableArtifactScope, operationKind: "create" | "import", authorityKey: string, idempotencyKeyInput: string): Promise<CreateEditableArtifactResult | null>;
+    createArtifact(input: CreateEditableArtifactStoreRequest): Promise<CreateEditableArtifactStoreResult>;
+    readScopeCreateAuthorizationRevision(scope: EditableArtifactScope): Promise<number>;
+    advanceScopeCreateAuthorizationRevision(scope: EditableArtifactScope, expectedRevision: number, nextRevision: number): Promise<Readonly<{
+        applied: boolean;
+        authorizationRevision: number;
+    }>>;
+    seedArtifact(input: SeedInMemoryEditableArtifact): Promise<EditableArtifact>;
+    getArtifact(scope: EditableArtifactScope, artifactId: EditableArtifactId): Promise<EditableArtifact | null>;
+    readArtifactAtAuthorizationRevision(scope: EditableArtifactScope, artifactId: EditableArtifactId, expectedAuthorizationRevision: number): Promise<ReadEditableArtifactAtAuthorizationRevisionResult>;
+    /** Test/admin seam modeling the local policy invalidation transaction. */
+    advanceAuthorizationRevision(scope: EditableArtifactScope, artifactId: EditableArtifactId, expectedRevision: number, nextRevision: number): Promise<Readonly<{
+        applied: boolean;
+        authorizationRevision: number;
+    }>>;
+    readTransactionBasis(scope: EditableArtifactScope, artifactId: EditableArtifactId, request: ReadEditableArtifactTransactionBasisRequest): Promise<EditableArtifactTransactionBasis>;
+    readCurrentKernelState(scope: EditableArtifactScope, artifactId: EditableArtifactId, expectedAuthorizationRevision: number): Promise<Readonly<{
+        kind: "basis";
+        state: EditableArtifactKernelState;
+    }> | Readonly<{
+        kind: "authorization_stale";
+    }>>;
+    tryCommitAppliedTransaction(request: TryCommitAppliedEditableArtifactTransactionRequest): Promise<TryCommitAppliedEditableArtifactTransactionResult>;
+    withSnapshotPublicationLock<T>(scope: EditableArtifactScope, artifactId: EditableArtifactId, callback: (unitOfWork: EditableArtifactSnapshotUnitOfWorkPort) => Promise<T>): Promise<T>;
+    claimLiveOutbox(request: ClaimEditableArtifactLiveOutboxRequest): Promise<readonly EditableArtifactLiveOutboxRecord[]>;
+    markLiveOutboxPublished(input: {
+        outboxId: EditableArtifactOutboxId;
+        owner: string;
+        attemptCount: number;
+    }): Promise<void>;
+    releaseLiveOutbox(input: {
+        outboxId: EditableArtifactOutboxId;
+        owner: string;
+        attemptCount: number;
+    }): Promise<void>;
+    renewLiveOutbox(input: {
+        outboxId: EditableArtifactOutboxId;
+        owner: string;
+        attemptCount: number;
+        leaseDurationMs: number;
+    }): Promise<void>;
+    retryLiveOutbox(input: {
+        outboxId: EditableArtifactOutboxId;
+        owner: string;
+        attemptCount: number;
+        retryDelayMs: number;
+        errorCode: EditableArtifactOutboxRetryFailureCode;
+    }): Promise<void>;
+    deadLetterLiveOutbox(input: {
+        outboxId: EditableArtifactOutboxId;
+        owner: string;
+        attemptCount: number;
+        errorCode: EditableArtifactOutboxDeadLetterFailureCode;
+    }): Promise<void>;
+    listReceipts(scope: EditableArtifactScope, artifactId: EditableArtifactId): Promise<readonly EditableArtifactReceipt[]>;
+    listOperations(scope: EditableArtifactScope, artifactId: EditableArtifactId): Promise<readonly EditableArtifactOperationRecord[]>;
+    listCommittedTransactions(scope: EditableArtifactScope, artifactId: EditableArtifactId): Promise<readonly EditableArtifactCommittedTransactionRecord[]>;
+    listSnapshots(scope: EditableArtifactScope, artifactId: EditableArtifactId): Promise<readonly EditableArtifactSnapshotMetadata[]>;
+    listOutbox(): Promise<readonly EditableArtifactLiveOutboxRecord[]>;
+    private inspectAggregate;
+    private findOutbox;
+    private exclusive;
+}
+/** Deterministic persisted-namespace allocator for reference tests/adapters. */
+export declare class InMemoryEditableArtifactStableIdFactory implements EditableArtifactStableIdFactoryPort {
+    private nextCounter;
+    private readonly namespace;
+    constructor(namespace: bigint | string, initialCounter?: bigint);
+    next(_kind: EditableArtifactStableIdKind): EditableArtifactStableId;
+}
+export declare class SystemEditableArtifactClock implements EditableArtifactClockPort {
+    now(): Date;
+}

package/dist/domain/editable-artifacts/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./errors.js";
+export * from "./durable-export.js";
+export * from "./agent-application.js";
+export * from "./durable-export-postgres.js";
+export * from "./hash.js";
+export * from "./in-memory.js";
+export * from "./ports.js";
+export * from "./postgres-adapters.js";
+export * from "./service.js";
+export * from "./snapshot-verifier.js";
+export * from "./snapshot-compaction.js";
+export * from "./snapshot-verifier-genesis.js";
+export * from "./snapshot-verifier-materialization.js";
+export * from "./types.js";