@opengeni/core 0.21.10 → 0.24.1

package/dist/domain/editable-artifacts/snapshot-verifier.d.ts

@@ -0,0 +1,118 @@
+import { type BoundedObjectReadPort } from "@opengeni/storage";
+import type { EditableArtifactSnapshotVerifierPort } from "./ports.js";
+import { type EditableArtifactCausalFrontier, type EditableArtifactContentHash, type EditableArtifactId, type EditableArtifactScope, type EditableArtifactModality, type EditableArtifactStateHash, type PublishEditableArtifactSnapshotRequest } from "./types.js";
+export declare const MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES: number;
+export declare const MAX_EDITABLE_ARTIFACT_SNAPSHOT_TAIL_BYTES: number;
+export declare const MAX_EDITABLE_ARTIFACT_SNAPSHOT_TAIL_SEGMENTS = 100000;
+export declare const MAX_EDITABLE_ARTIFACT_SNAPSHOT_TAIL_SEGMENT_BYTES: number;
+export type EditableArtifactSnapshotVerificationErrorCode = "cancelled" | "canonical_mismatch" | "content_hash_mismatch" | "content_type_mismatch" | "coverage_mismatch" | "frontier_mismatch" | "identity_mismatch" | "kernel_rejected" | "limit_exceeded" | "object_changed" | "object_missing" | "replay_invalid" | "state_hash_mismatch" | "storage_failure" | "truncated" | "version_mismatch";
+/** Intentionally contains no provider diagnostic, reference, key, or URL. */
+export declare class EditableArtifactSnapshotVerificationError extends Error {
+    readonly code: EditableArtifactSnapshotVerificationErrorCode;
+    constructor(code: EditableArtifactSnapshotVerificationErrorCode);
+}
+type EditableArtifactSnapshotReplaySegmentCommon = Readonly<{
+    sequenceStart: number;
+    sequenceEnd: number;
+    contentHash: EditableArtifactContentHash;
+    bytes: Uint8Array;
+}>;
+export type EditableArtifactSnapshotReplaySegment = (EditableArtifactSnapshotReplaySegmentCommon & Readonly<{
+    modality: "spreadsheet";
+    operationProtocolVersion: number;
+}>) | (EditableArtifactSnapshotReplaySegmentCommon & Readonly<{
+    modality: "document" | "presentation";
+}>);
+type EditableArtifactSnapshotReplayPlanCommon = Readonly<{
+    modality: EditableArtifactModality;
+    /** Must equal the verified snapshot's coverage boundary. */
+    baseHeadSequence: number;
+    targetHeadSequence: number;
+    targetStateHash: EditableArtifactStateHash;
+    segments: AsyncIterable<EditableArtifactSnapshotReplaySegment>;
+}>;
+export type EditableArtifactSnapshotReplayPlan = (EditableArtifactSnapshotReplayPlanCommon & Readonly<{
+    modality: "spreadsheet";
+    targetCausalFrontier: EditableArtifactCausalFrontier;
+}>) | (EditableArtifactSnapshotReplayPlanCommon & Readonly<{
+    modality: "document" | "presentation";
+    targetNativeRevision: number;
+}>);
+/** Optional authoritative tail used to prove reconstruction to a later head. */
+export interface EditableArtifactSnapshotReplayPlanPort {
+    resolve(input: {
+        scope: EditableArtifactScope;
+        artifactId: EditableArtifactId;
+        snapshot: PublishEditableArtifactSnapshotRequest;
+        signal?: AbortSignal;
+    }): Promise<EditableArtifactSnapshotReplayPlan | null>;
+}
+type IsolatedEditableArtifactSnapshotKernelResultCommon = Readonly<{
+    modality: EditableArtifactModality;
+    /** True only when canonical re-encoding was byte-equivalent to the input. */
+    canonicalReencodeVerified: true;
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    canonicalByteSize: number;
+    canonicalContentHash: EditableArtifactContentHash;
+    coveredHeadSequence: number;
+    stateHash: EditableArtifactStateHash;
+    modelSchemaVersion: number;
+    kernelVersion: string;
+}>;
+export type IsolatedEditableArtifactSnapshotKernelResult = (IsolatedEditableArtifactSnapshotKernelResultCommon & Readonly<{
+    modality: "spreadsheet";
+    /** True only after decoding dots, vectors, tombstones, and undo metadata. */
+    fullCrdtStateVerified: true;
+    coveredCausalFrontier: EditableArtifactCausalFrontier;
+    operationProtocolVersion: number;
+    crdtStateVersion: number;
+    replayedTarget?: Readonly<{
+        headSequence: number;
+        causalFrontier: EditableArtifactCausalFrontier;
+        stateHash: EditableArtifactStateHash;
+    }>;
+}>) | (IsolatedEditableArtifactSnapshotKernelResultCommon & Readonly<{
+    modality: "document" | "presentation";
+    nativeRevision: number;
+    replayedTarget?: Readonly<{
+        headSequence: number;
+        nativeRevision: number;
+        stateHash: EditableArtifactStateHash;
+    }>;
+}>);
+/** Adapter to the exact no-network native kernel; JavaScript models are never authority. */
+export interface IsolatedEditableArtifactSnapshotKernelPort {
+    verifyAndReconstruct(input: {
+        scope: EditableArtifactScope;
+        artifactId: EditableArtifactId;
+        modality: EditableArtifactModality;
+        /** Durable coverage/version metadata stays distinct from native revision. */
+        expectedSnapshot: PublishEditableArtifactSnapshotRequest;
+        snapshotChunks: AsyncIterable<Uint8Array>;
+        expectedSnapshotByteSize: number;
+        replayPlan?: EditableArtifactSnapshotReplayPlan;
+        signal?: AbortSignal;
+    }): Promise<IsolatedEditableArtifactSnapshotKernelResult>;
+}
+export type ProductionEditableArtifactSnapshotVerifierDependencies = Readonly<{
+    objects: BoundedObjectReadPort;
+    kernel: IsolatedEditableArtifactSnapshotKernelPort;
+    replayPlans?: EditableArtifactSnapshotReplayPlanPort;
+    maxSnapshotBytes?: number;
+    maxReplayBytes?: number;
+    maxReplaySegments?: number;
+    snapshotChunkBytes?: number;
+}>;
+/**
+ * Production verifier for the existing domain port. Publication remains a
+ * separate, short forward-only database CAS after this method succeeds.
+ */
+export declare class ProductionEditableArtifactSnapshotVerifier implements EditableArtifactSnapshotVerifierPort {
+    #private;
+    constructor(dependencies: ProductionEditableArtifactSnapshotVerifierDependencies);
+    verify(input: Parameters<EditableArtifactSnapshotVerifierPort["verify"]>[0] & {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,410 @@
+import type { EditableArtifactMutationIntent as ContractEditableArtifactMutationIntent, EDITABLE_ARTIFACT_INTENT_VERSION } from "@opengeni/contracts/editable-artifacts";
+/**
+ * Domain vocabulary for collaborative, editable Office-like artifacts.
+ *
+ * This is intentionally unrelated to OpenGeni's published HTML artifacts and
+ * document-ingestion records. An editable artifact is mutable canonical model
+ * state plus a causally ordered operation history.
+ */
+declare const editableArtifactIdBrand: unique symbol;
+declare const editableArtifactTransactionIdBrand: unique symbol;
+declare const editableArtifactReceiptIdBrand: unique symbol;
+declare const editableArtifactSnapshotIdBrand: unique symbol;
+declare const editableArtifactOutboxIdBrand: unique symbol;
+declare const editableArtifactOperationIdBrand: unique symbol;
+declare const editableArtifactReplicaIdBrand: unique symbol;
+declare const editableArtifactClientTransactionIdBrand: unique symbol;
+declare const editableArtifactRequestHashBrand: unique symbol;
+declare const editableArtifactStateHashBrand: unique symbol;
+declare const editableArtifactContentHashBrand: unique symbol;
+export type EditableArtifactId = string & {
+    readonly [editableArtifactIdBrand]: true;
+};
+export type EditableArtifactTransactionId = string & {
+    readonly [editableArtifactTransactionIdBrand]: true;
+};
+export type EditableArtifactReceiptId = string & {
+    readonly [editableArtifactReceiptIdBrand]: true;
+};
+export type EditableArtifactSnapshotId = string & {
+    readonly [editableArtifactSnapshotIdBrand]: true;
+};
+export type EditableArtifactOutboxId = string & {
+    readonly [editableArtifactOutboxIdBrand]: true;
+};
+export type EditableArtifactOperationId = string & {
+    readonly [editableArtifactOperationIdBrand]: true;
+};
+export type EditableArtifactReplicaId = string & {
+    readonly [editableArtifactReplicaIdBrand]: true;
+};
+export type EditableArtifactClientTransactionId = string & {
+    readonly [editableArtifactClientTransactionIdBrand]: true;
+};
+export type EditableArtifactRequestHash = string & {
+    readonly [editableArtifactRequestHashBrand]: true;
+};
+export type EditableArtifactStateHash = string & {
+    readonly [editableArtifactStateHashBrand]: true;
+};
+export type EditableArtifactContentHash = string & {
+    readonly [editableArtifactContentHashBrand]: true;
+};
+export type EditableArtifactStableId = EditableArtifactId | EditableArtifactTransactionId | EditableArtifactReceiptId | EditableArtifactSnapshotId | EditableArtifactOutboxId | EditableArtifactOperationId;
+export declare function editableArtifactId(value: string): EditableArtifactId;
+export declare function editableArtifactTransactionId(value: string): EditableArtifactTransactionId;
+export declare function editableArtifactReceiptId(value: string): EditableArtifactReceiptId;
+export declare function editableArtifactSnapshotId(value: string): EditableArtifactSnapshotId;
+export declare function editableArtifactOutboxId(value: string): EditableArtifactOutboxId;
+export declare function editableArtifactOperationId(value: string): EditableArtifactOperationId;
+export declare function editableArtifactReplicaId(value: string): EditableArtifactReplicaId;
+export declare function editableArtifactClientTransactionId(value: string): EditableArtifactClientTransactionId;
+export declare function editableArtifactRequestHash(value: string): EditableArtifactRequestHash;
+export declare function editableArtifactStateHash(value: string): EditableArtifactStateHash;
+export declare function editableArtifactContentHash(value: string): EditableArtifactContentHash;
+export type EditableArtifactScope = Readonly<{
+    accountId: string;
+    workspaceId: string;
+}>;
+export declare function editableArtifactScope(input: EditableArtifactScope): EditableArtifactScope;
+export type EditableArtifactModality = "spreadsheet" | "presentation" | "document";
+export type EditableArtifactLifecycleState = "active" | "archived";
+export type EditableArtifactPermission = "create" | "read" | "edit" | "import" | "export" | "manage";
+export type EditableArtifactHumanActor = Readonly<{
+    kind: "human";
+    subjectId: string;
+    replicaId: EditableArtifactReplicaId;
+}>;
+export type EditableArtifactAgentActor = Readonly<{
+    kind: "agent";
+    subjectId: string;
+    replicaId: EditableArtifactReplicaId;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    generation: number;
+}>;
+export type EditableArtifactServiceActor = Readonly<{
+    kind: "service";
+    subjectId: string;
+    replicaId: EditableArtifactReplicaId;
+    service: string;
+}>;
+export type EditableArtifactActor = EditableArtifactHumanActor | EditableArtifactAgentActor | EditableArtifactServiceActor;
+export declare function validateEditableArtifactActor(actor: EditableArtifactActor): void;
+/** Exact authority identity used by idempotency and operation authorship. */
+export declare function editableArtifactActorKey(actor: EditableArtifactActor): string;
+export type EditableArtifactCausalEntry = Readonly<{
+    replicaId: EditableArtifactReplicaId;
+    counter: number;
+}>;
+/** Sorted, duplicate-free semantic causality. Never substitute headSequence. */
+export type EditableArtifactCausalFrontier = readonly EditableArtifactCausalEntry[];
+export declare function editableArtifactCausalFrontier(entries: Iterable<EditableArtifactCausalEntry>): EditableArtifactCausalFrontier;
+export declare function causalCounter(frontier: EditableArtifactCausalFrontier, replicaId: EditableArtifactReplicaId): number;
+export declare function causalFrontierDominates(candidate: EditableArtifactCausalFrontier, required: EditableArtifactCausalFrontier): boolean;
+export declare function causalFrontiersEqual(left: EditableArtifactCausalFrontier, right: EditableArtifactCausalFrontier): boolean;
+export declare function mergeCausalFrontiers(...frontiers: readonly EditableArtifactCausalFrontier[]): EditableArtifactCausalFrontier;
+export type EditableArtifactCausalDot = EditableArtifactCausalEntry;
+type EditableArtifactCommon = Readonly<{
+    scope: EditableArtifactScope;
+    id: EditableArtifactId;
+    title: string;
+    lifecycle: EditableArtifactLifecycleState;
+    /** Local policy revision atomically fenced with every durable write. */
+    authorizationRevision: number;
+    headSequence: number;
+    stateHash: EditableArtifactStateHash;
+    currentSnapshotId: EditableArtifactSnapshotId | null;
+    createdAt: string;
+    updatedAt: string;
+}>;
+export type EditableArtifactSpreadsheet = EditableArtifactCommon & Readonly<{
+    modality: "spreadsheet";
+    causalFrontier: EditableArtifactCausalFrontier;
+}>;
+export type EditableArtifactSerialized = EditableArtifactCommon & Readonly<{
+    modality: "document" | "presentation";
+}>;
+export type EditableArtifact = EditableArtifactSpreadsheet | EditableArtifactSerialized;
+export type CreateEditableArtifactRequest = Readonly<{
+    idempotencyKey: EditableArtifactClientTransactionId;
+    modality: EditableArtifactModality;
+    title: string;
+}>;
+export type EditableArtifactOriginOperation = "create" | "import";
+export declare const EDITABLE_ARTIFACT_ORIGINAL_IMPORT_MAX_BYTES: number;
+/**
+ * Immutable, already-retained Office source for one imported artifact. The
+ * object reference is infrastructure-owned; the remaining facts are bound into
+ * the import idempotency hash and independently checked by the snapshot
+ * verifier before publication.
+ */
+export type EditableArtifactOriginalImport = Readonly<{
+    fileId: string;
+    blobReference: string;
+    byteSize: number;
+    contentHash: EditableArtifactContentHash;
+    mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+}>;
+type ImportedEditableArtifactSnapshotRequest = PublishEditableArtifactSnapshotRequest extends infer Snapshot ? Snapshot extends PublishEditableArtifactSnapshotRequest ? Omit<Snapshot, "snapshotId" | "verifiedAt"> : never : never;
+export type ImportEditableArtifactRequest = Readonly<{
+    idempotencyKey: EditableArtifactClientTransactionId;
+    modality: EditableArtifactModality;
+    title: string;
+    originalImport: EditableArtifactOriginalImport;
+    /** Snapshot identity and verification/publication timestamps remain server-owned. */
+    snapshot: ImportedEditableArtifactSnapshotRequest;
+}>;
+export type EditableArtifactCreationReceipt = Readonly<{
+    receiptId: EditableArtifactReceiptId;
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    operationKind: EditableArtifactOriginOperation;
+    authorityKey: string;
+    idempotencyKey: EditableArtifactClientTransactionId;
+    /** Canonical hash of client semantics only; generated genesis facts are result data. */
+    requestHash: EditableArtifactRequestHash;
+    genesisSnapshotId: EditableArtifactSnapshotId;
+    createdAt: string;
+}>;
+export type CreateEditableArtifactResult = Readonly<{
+    artifact: EditableArtifact;
+    genesisSnapshot: EditableArtifactSnapshotMetadata;
+    creationReceipt: EditableArtifactCreationReceipt;
+    replayed: boolean;
+}>;
+/** Exact decoded shared OGATX001 contract; never independently recanonicalized. */
+export type EditableArtifactMutationIntent = ContractEditableArtifactMutationIntent;
+/** Server-validated/branded projection of the exact decoded shared contract. */
+export type ValidatedEditableArtifactMutationIntent = Readonly<{
+    envelopeVersion: typeof EDITABLE_ARTIFACT_INTENT_VERSION;
+    protocolVersion: number;
+    modelSchemaVersion: number;
+    commandProtocolVersion: number;
+    artifactId: EditableArtifactId;
+    clientTransactionId: EditableArtifactClientTransactionId;
+    replicaId: EditableArtifactReplicaId;
+    /** One persisted counter is reserved per atomic local transaction. */
+    replicaCounter: number;
+    /** Null only for the first transaction authored by this replica. */
+    previousLocalTransactionId: EditableArtifactClientTransactionId | null;
+    observedHeadSequence: number;
+    causalBase: EditableArtifactCausalFrontier;
+    selectiveUndoOperationIds: readonly EditableArtifactOperationId[];
+    /** Canonical client commands; only the authoritative kernel may decode them. */
+    commandBytes: Uint8Array;
+}>;
+export type ApplyEditableArtifactTransactionRequest = Readonly<{
+    /** Exact owned canonical OGATX001 bytes. */
+    intentBytes: Uint8Array;
+    requestHash: EditableArtifactRequestHash;
+    /**
+     * Optional exact-head fence for clients that author from a bounded read.
+     * Browser replicas deliberately omit it so spreadsheet CRDT operations can
+     * merge. Agent edits always provide it and must re-inspect after a conflict.
+     */
+    expectedHead?: Readonly<{
+        sequence: number;
+        stateHash: EditableArtifactStateHash;
+    }>;
+}>;
+/** Metadata indexed for authorship/selective undo; command data stays in OGACO. */
+export type EditableArtifactKernelOperation = Readonly<{
+    operationId: EditableArtifactOperationId;
+    dot: EditableArtifactCausalDot;
+}>;
+export type EditableArtifactOperationRecord = EditableArtifactKernelOperation & Readonly<{
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    serverTransactionId: EditableArtifactTransactionId;
+    sequence: number;
+    actorKey: string;
+    createdAt: string;
+}>;
+/**
+ * One exact canonical OGACO transaction. The opaque bytes are the sole
+ * authoritative operation payload and are replayed atomically by the native
+ * or WASM kernel. Core never decodes modality commands from this envelope.
+ */
+type EditableArtifactCommittedTransactionCommon = Readonly<{
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    serverTransactionId: EditableArtifactTransactionId;
+    requestHash: EditableArtifactRequestHash;
+    sequenceStart: number;
+    sequenceEnd: number;
+    priorStateHash: EditableArtifactStateHash;
+    stateHash: EditableArtifactStateHash;
+    modelSchemaVersion: number;
+    kernelVersion: string;
+    committedTransactionBytes: Uint8Array;
+    committedAt: string;
+}>;
+export type EditableArtifactSpreadsheetCommittedTransactionRecord = EditableArtifactCommittedTransactionCommon & Readonly<{
+    modality: "spreadsheet";
+    dot: EditableArtifactCausalDot;
+    resolvedCausalBase: EditableArtifactCausalFrontier;
+    resultingCausalFrontier: EditableArtifactCausalFrontier;
+    operationIds: readonly EditableArtifactOperationId[];
+    operationProtocolVersion: number;
+}>;
+export type EditableArtifactSerializedCommittedTransactionRecord = EditableArtifactCommittedTransactionCommon & Readonly<{
+    modality: "document" | "presentation";
+    commitProtocolVersion: number;
+    priorNativeRevision: number;
+    nativeRevision: number;
+    commandCount: number;
+    nativeReceiptBytes: Uint8Array;
+}>;
+export type EditableArtifactCommittedTransactionRecord = EditableArtifactSpreadsheetCommittedTransactionRecord | EditableArtifactSerializedCommittedTransactionRecord;
+type EditableArtifactReceiptCommon = Readonly<{
+    receiptId: EditableArtifactReceiptId;
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    serverTransactionId: EditableArtifactTransactionId;
+    clientTransactionId: EditableArtifactClientTransactionId;
+    replicaId: EditableArtifactReplicaId;
+    replicaCounter: number;
+    previousLocalTransactionId: EditableArtifactClientTransactionId | null;
+    requestHash: EditableArtifactRequestHash;
+    /** Exact canonical bytes whose SHA-256 is requestHash. */
+    intentBytes: Uint8Array;
+    actorKey: string;
+    sequenceStart: number;
+    sequenceEnd: number;
+    priorStateHash: EditableArtifactStateHash;
+    stateHash: EditableArtifactStateHash;
+    intentEnvelopeVersion: number;
+    intentProtocolVersion: number;
+    commandProtocolVersion: number;
+    kernelVersion: string;
+    modelSchemaVersion: number;
+    committedAt: string;
+}>;
+export type EditableArtifactSpreadsheetReceipt = EditableArtifactReceiptCommon & Readonly<{
+    modality: "spreadsheet";
+    causalBase: EditableArtifactCausalFrontier;
+    resolvedCausalBase: EditableArtifactCausalFrontier;
+    resultingCausalFrontier: EditableArtifactCausalFrontier;
+    stateHash: EditableArtifactStateHash;
+    operationCount: number;
+    selectiveUndoOperationIds: readonly EditableArtifactOperationId[];
+    operationProtocolVersion: number;
+}>;
+export type EditableArtifactSerializedReceipt = EditableArtifactReceiptCommon & Readonly<{
+    modality: "document" | "presentation";
+    commitProtocolVersion: number;
+    priorNativeRevision: number;
+    nativeRevision: number;
+    commandCount: number;
+}>;
+export type EditableArtifactReceipt = EditableArtifactSpreadsheetReceipt | EditableArtifactSerializedReceipt;
+export type ApplyEditableArtifactTransactionResult = Readonly<{
+    receipt: EditableArtifactReceipt;
+    replayed: boolean;
+}>;
+type EditableArtifactSnapshotMetadataCommon = Readonly<{
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    snapshotId: EditableArtifactSnapshotId;
+    blobReference: string;
+    byteSize: number;
+    contentHash: EditableArtifactContentHash;
+    mimeType: "application/vnd.opengeni.editable-artifact-snapshot";
+    coveredHeadSequence: number;
+    stateHash: EditableArtifactStateHash;
+    modelSchemaVersion: number;
+    kernelVersion: string;
+    verifiedAt: string;
+    publishedAt: string;
+}>;
+export type EditableArtifactSpreadsheetSnapshotMetadata = EditableArtifactSnapshotMetadataCommon & Readonly<{
+    modality: "spreadsheet";
+    coveredCausalFrontier: EditableArtifactCausalFrontier;
+    operationProtocolVersion: number;
+    crdtStateVersion: number;
+}>;
+export type EditableArtifactSerializedSnapshotMetadata = EditableArtifactSnapshotMetadataCommon & Readonly<{
+    modality: "document" | "presentation";
+    nativeRevision: number;
+}>;
+export type EditableArtifactSnapshotMetadata = EditableArtifactSpreadsheetSnapshotMetadata | EditableArtifactSerializedSnapshotMetadata;
+export type PublishEditableArtifactSnapshotRequest = EditableArtifactSnapshotMetadata extends infer Snapshot ? Snapshot extends EditableArtifactSnapshotMetadata ? Omit<Snapshot, "scope" | "artifactId" | "publishedAt"> : never : never;
+type EditableArtifactTransactionCommittedEventCommon = Readonly<{
+    kind: "transaction_committed";
+    schemaVersion: 1;
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    serverTransactionId: EditableArtifactTransactionId;
+    sequenceStart: number;
+    sequenceEnd: number;
+    stateHash: EditableArtifactStateHash;
+    committedAt: string;
+}>;
+export type EditableArtifactTransactionCommittedEvent = (EditableArtifactTransactionCommittedEventCommon & Readonly<{
+    modality: "spreadsheet";
+    operationProtocolVersion: number;
+}>) | (EditableArtifactTransactionCommittedEventCommon & Readonly<{
+    modality: "document" | "presentation";
+    commitProtocolVersion: number;
+}>);
+type EditableArtifactSnapshotPublishedEventCommon = Readonly<{
+    kind: "snapshot_published";
+    schemaVersion: 1;
+    scope: EditableArtifactScope;
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    snapshotId: EditableArtifactSnapshotId;
+    coveredHeadSequence: number;
+    stateHash: EditableArtifactStateHash;
+    publishedAt: string;
+}>;
+export type EditableArtifactSnapshotPublishedEvent = (EditableArtifactSnapshotPublishedEventCommon & Readonly<{
+    modality: "spreadsheet";
+    operationProtocolVersion: number;
+}>) | (EditableArtifactSnapshotPublishedEventCommon & Readonly<{
+    modality: "document" | "presentation";
+}>);
+/** Durable live fanout hint. Consumers gap-fill canonical transactions. */
+export type EditableArtifactLiveEvent = EditableArtifactTransactionCommittedEvent | EditableArtifactSnapshotPublishedEvent;
+export type EditableArtifactOutboxRetryFailureCode = "broker_unavailable" | "broker_backpressure" | "publish_timeout";
+export type EditableArtifactOutboxDeadLetterFailureCode = "invalid_hint" | "oversized_hint";
+export type EditableArtifactOutboxErrorCode = EditableArtifactOutboxRetryFailureCode | EditableArtifactOutboxDeadLetterFailureCode;
+export type EditableArtifactLiveOutboxRecord = Readonly<{
+    outboxId: EditableArtifactOutboxId;
+    event: EditableArtifactLiveEvent;
+    state: "pending" | "publishing" | "published" | "dead_lettered";
+    attemptCount: number;
+    leaseOwner: string | null;
+    leaseExpiresAt: string | null;
+    nextAttemptAt: string;
+    lastErrorCode: EditableArtifactOutboxErrorCode | null;
+    publishedAt: string | null;
+    deadLetteredAt: string | null;
+    createdAt: string;
+}>;
+export type EditableArtifactSequenceCheckpoint = Readonly<{
+    modality: "spreadsheet";
+    headSequence: number;
+    causalFrontier: EditableArtifactCausalFrontier;
+    stateHash: EditableArtifactStateHash;
+}> | Readonly<{
+    modality: "document" | "presentation";
+    headSequence: number;
+    nativeRevision: number;
+    stateHash: EditableArtifactStateHash;
+}>;
+export declare function assertNonnegativeSafeInteger(value: number, label: string): void;
+export declare function assertPositiveSafeInteger(value: number, label: string): void;
+export declare function assertIsoTimestamp(value: string, label: string): void;
+export declare function assertBoundedArtifactTitle(value: string): void;
+export declare function assertBoundedOpaqueReference(value: string, label: string): void;
+export declare function assertBoundedKernelVersion(value: unknown): asserts value is string;
+/** Locale-independent ordering used by every canonical wire/hash projection. */
+export declare function compareCodeUnits(left: string, right: string): number;
+export {};

package/dist/domain/memory-slack-delivery.d.ts

@@ -0,0 +1,19 @@
+import type { MemorySlackPublicationDistribution } from "@opengeni/contracts";
+import { type CorrectWorkspaceMemoryInput, type CorrectWorkspaceMemoryResult, type Database, type EnqueueMemorySlackPublicationResult, type MemoryEmbedder, type MemorySlackPublicationActor, type SaveWorkspaceMemoryInput, type SaveWorkspaceMemoryResult } from "@opengeni/db";
+import { type MemorySlackOrigin, type MemorySlackPublicationDecision } from "./memory-slack-publication.js";
+export type MemorySlackPublicationCommitRequest = {
+    distribution: MemorySlackPublicationDistribution;
+    actor: MemorySlackPublicationActor;
+    ownerLabel?: string | null;
+    origin?: MemorySlackOrigin;
+};
+export type MemorySlackPublicationCommitResult = {
+    decision: MemorySlackPublicationDecision | null;
+    enqueue: EnqueueMemorySlackPublicationResult | null;
+};
+export declare function saveWorkspaceMemoryWithSlackPublication(db: Database, input: SaveWorkspaceMemoryInput, publication: MemorySlackPublicationCommitRequest | null, embedder?: MemoryEmbedder): Promise<SaveWorkspaceMemoryResult & {
+    slackPublication: MemorySlackPublicationCommitResult;
+}>;
+export declare function correctWorkspaceMemoryWithSlackPublication(db: Database, input: CorrectWorkspaceMemoryInput, publication: MemorySlackPublicationCommitRequest | null, embedder?: MemoryEmbedder): Promise<CorrectWorkspaceMemoryResult & {
+    slackPublication: MemorySlackPublicationCommitResult;
+}>;

package/dist/domain/packs.d.ts

@@ -1,4 +1,4 @@
-import { CapabilityPack, type ScheduledTaskAgentConfig, type SocialConnection } from "@opengeni/contracts";
+import { CapabilityPack, type CapabilityPackSkill, type PackInstallationPreview, type ScheduledTaskAgentConfig, type SocialConnection } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 export declare const MARKETING_SOCIAL_PACK_ID = "marketing-social-daily-analysis";
 export declare function listCapabilityPacks(): CapabilityPack[];
@@ -12,6 +12,34 @@ export declare function isBuiltInCapabilityPack(packId: string): boolean;
  */
 export declare function listWorkspaceCapabilityPacks(db: Database, workspaceId: string): Promise<CapabilityPack[]>;
 export declare function resolveCapabilityPack(db: Database, workspaceId: string, packId: string): Promise<CapabilityPack | null>;
+export declare function capabilityPackManifestDigest(pack: CapabilityPack): string;
+/** True when the Pack must use the owner-aware V2 preview/install lifecycle. */
+export declare function capabilityPackRequiresInstallationPlan(pack: CapabilityPack): boolean;
+export type InlinePackSkillInstall = {
+    componentKey: string;
+    capabilityId: string;
+    pluginKey: string;
+    sourceUrl: string;
+    repositoryUrl: string;
+    sourceCommit: string;
+    sourcePath: string;
+    name: string;
+    description: string;
+    contentSha256: string;
+    totalBytes: number;
+    files: Array<{
+        path: string;
+        content: string;
+        byteSize: number;
+        contentSha256: string;
+    }>;
+};
+/** Convert a legacy inline Pack Skill into the ordinary immutable Skill model. */
+export declare function inlinePackSkillInstall(pack: CapabilityPack, skill: CapabilityPackSkill): InlinePackSkillInstall;
+export declare function previewCapabilityPackInstallation(db: Database, workspaceId: string, pack: CapabilityPack, options?: {
+    rigId?: string;
+    variableSetId?: string;
+}): Promise<PackInstallationPreview>;
 /**
  * v1 pack-scoped runtime rule: at most one enabled pack per workspace may
  * declare a `sandboxImage` — there is deliberately no image composition or

package/dist/domain/personal-connection-delegations.d.ts

@@ -15,6 +15,10 @@ export type AuthorizedSocialConnection = {
     connection: SocialConnection;
     subjectId: string | null;
 };
+export type AuthorizedAtlassianConnection = {
+    connection: ConnectionMetadata;
+    subjectId: string | null;
+};
 export declare function directPersonalConnectionSubjectId(turn: Pick<SessionTurn, "source" | "initiator" | "initiatorContext">): string | undefined;
 export declare function personalConnectionDelegationSourceForGrant(grant: AccessGrant): PersonalConnectionDelegationSource;
 export declare function authorizedSocialConnectionsForGrant(input: {
@@ -22,6 +26,10 @@ export declare function authorizedSocialConnectionsForGrant(input: {
     grant: AccessGrant;
     limit?: number;
 }): Promise<AuthorizedSocialConnection[]>;
+export declare function authorizedAtlassianConnectionsForGrant(input: {
+    db: Database;
+    grant: AccessGrant;
+}): Promise<AuthorizedAtlassianConnection[]>;
 export declare function selectedPersonalConnectionServers(settings: Pick<Settings, "mcpServers">, tools: ToolRef[]): McpServerConfig[];
 export declare function personalConnectionDelegationsFromVisibleConnections(input: {
     servers: McpServerConfig[];
@@ -37,7 +45,7 @@ export declare function personalConnectionDelegationForServer(delegations: McpPe
 type ConnectionCredentialResolver = (request: ResolveConnectionCredentialInput) => Promise<ResolveConnectionCredentialResult>;
 /**
  * Resolves subject-owned MCP credentials only through the exact authority
- * frozen on the causal turn. A direct human subject, worker Toolspace caller,
+ * frozen on the causal turn. A direct human subject, worker Codemode caller,
  * retry, or recovery can identify the caller, but none may widen or replace
  * the persisted connection UUID.
  */

package/dist/domain/scheduled-tasks.d.ts

@@ -1,8 +1,8 @@
 import type { Settings } from "@opengeni/config";
 import type { AccessGrant, McpPersonalConnectionDelegation, ScheduledTask, ScheduledTaskAgentConfig, Session, SessionAuthorizationPort, SessionAuthorizationSurface, CreateScheduledTaskRequest as CreateScheduledTaskPayload, UpdateScheduledTaskRequest as UpdateScheduledTaskPayload } from "@opengeni/contracts";
 import { type Database, type UpdateScheduledTaskInput } from "@opengeni/db";
-import type { SessionWorkflowClient } from "../dependencies";
-import type { ObjectStorageDependency } from "../dependencies";
+import type { SessionWorkflowClient } from "../dependencies.js";
+import type { ObjectStorageDependency } from "../dependencies.js";
 /**
  * Whether a raw scheduled-task payload explicitly set agentConfig.tools.
  * Zod's `.default([])` erases the distinction between "absent" and

package/dist/domain/session-tool-policy.d.ts

@@ -24,8 +24,8 @@ export declare function defaultSessionMcpServerIds(servers: Iterable<{
  */
 export declare function resolveSessionToolPolicy(input: SessionToolPolicyInput): ResolvedSessionToolPolicy;
 /** Current full runtime registry IDs, including configured static servers. */
-export declare function workspaceSessionToolPolicyServerIds(db: Database, workspaceId: string, settings: Settings): Promise<string[]>;
+export declare function workspaceSessionToolPolicyServerIds(db: Database, workspaceId: string, settings: Settings, subjectId?: string): Promise<string[]>;
 /** Current omitted-tools defaults: every configured runtime MCP is on. */
-export declare function workspaceSessionToolPolicyDefaultServerIds(db: Database, workspaceId: string, settings: Settings): Promise<string[]>;
+export declare function workspaceSessionToolPolicyDefaultServerIds(db: Database, workspaceId: string, settings: Settings, subjectId?: string): Promise<string[]>;
 /** Add a bounded, secret-safe effective projection to a session response. */
 export declare function sessionWithEffectiveToolPolicy(session: Session, workspaceServerIds: Iterable<string>, workspaceDefaultServerIds?: Iterable<string>): Session;