@knpkv/control-center 0.1.0

package/dist/server/server/persistence/object-store/BlobStore.d.ts

@@ -0,0 +1,37 @@
+import { Context, Crypto, Effect, FileSystem, Layer, Path } from "effect";
+import { WorkspaceId } from "../../../domain/identifiers.js";
+import { BlobRoot } from "../PersistenceConfig.js";
+import { BlobDigest } from "./BlobDigest.js";
+import { BlobClassification, BlobRef } from "./BlobRef.js";
+import { type BlobStoreError } from "./BlobStoreError.js";
+import type { BlobRange, BlobRangeRead, BlobReadStream, BlobVerification } from "./BlobStoreTypes.js";
+/** Options used when constructing the owner-only object directory. */
+export interface BlobStoreOptions {
+    readonly blobRoot: BlobRoot;
+    readonly maximumBlobBytes?: number | undefined;
+    readonly maximumReadAllBytes?: number | undefined;
+    readonly maximumRangeBytes?: number | undefined;
+}
+/** Result of a content-addressed write. */
+export interface BlobPutResult {
+    readonly ref: BlobRef;
+    readonly stored: boolean;
+}
+interface BlobStoreService {
+    readonly put: (workspaceId: WorkspaceId, bytes: Uint8Array, classification: BlobClassification) => Effect.Effect<BlobPutResult, BlobStoreError>;
+    readonly readAll: (workspaceId: WorkspaceId, digest: BlobDigest, maximumBytes?: number | undefined) => Effect.Effect<Uint8Array, BlobStoreError>;
+    readonly readRange: (workspaceId: WorkspaceId, digest: BlobDigest, range: BlobRange) => Effect.Effect<BlobRangeRead, BlobStoreError>;
+    readonly readStream: (workspaceId: WorkspaceId, digest: BlobDigest, range?: BlobRange | undefined) => Effect.Effect<BlobReadStream, BlobStoreError>;
+    /** Replace corrupt bytes only after ContentStore authorizes persisted reproducible-cache metadata. */
+    readonly repairReproducible: (workspaceId: WorkspaceId, bytes: Uint8Array) => Effect.Effect<BlobPutResult, BlobStoreError>;
+    readonly verify: (workspaceId: WorkspaceId, digest: BlobDigest) => Effect.Effect<BlobVerification, BlobStoreError>;
+}
+declare const BlobStore_base: Context.ServiceClass<BlobStore, "@knpkv/control-center/server/persistence/BlobStore", BlobStoreService>;
+/** Workspace-isolated, content-addressed byte storage. */
+export declare class BlobStore extends BlobStore_base {
+    static readonly layer: (options: BlobStoreOptions) => Layer.Layer<BlobStore, BlobStoreError, Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+}
+/** Constructs a blob store while capturing the platform services in its layer. */
+export declare const makeBlobStore: (options: BlobStoreOptions) => Effect.Effect<BlobStore["Service"], BlobStoreError, Crypto.Crypto | FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=BlobStore.d.ts.map

package/dist/server/server/persistence/object-store/BlobStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobStore.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/BlobStore.ts"],"names":[],"mappings":"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"}

package/dist/server/server/persistence/object-store/BlobStoreError.d.ts

@@ -0,0 +1,57 @@
+import { Schema } from "effect";
+declare const BlobStoreInputError_base: Schema.Class<BlobStoreInputError, Schema.TaggedStruct<"BlobStoreInputError", {
+    readonly operation: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A blob reference or read option did not satisfy the storage contract. */
+export declare class BlobStoreInputError extends BlobStoreInputError_base {
+}
+declare const BlobNotFoundError_base: Schema.Class<BlobNotFoundError, Schema.TaggedStruct<"BlobNotFoundError", {
+    readonly digest: Schema.brand<Schema.String, "BlobDigest">;
+}>, import("effect/Cause").YieldableError>;
+/** The requested blob does not exist in the selected workspace. */
+export declare class BlobNotFoundError extends BlobNotFoundError_base {
+}
+declare const BlobTooLargeError_base: Schema.Class<BlobTooLargeError, Schema.TaggedStruct<"BlobTooLargeError", {
+    readonly digest: Schema.Union<readonly [Schema.brand<Schema.String, "BlobDigest">, Schema.Null]>;
+    readonly actualBytes: Schema.Number;
+    readonly maximumBytes: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** A blob exceeded the operation's configured byte bound. */
+export declare class BlobTooLargeError extends BlobTooLargeError_base {
+}
+declare const BlobUnexpectedEofError_base: Schema.Class<BlobUnexpectedEofError, Schema.TaggedStruct<"BlobUnexpectedEofError", {
+    readonly operation: Schema.String;
+    readonly expectedBytes: Schema.Number;
+    readonly actualBytes: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** An opened blob ended before the exact requested byte count was read. */
+export declare class BlobUnexpectedEofError extends BlobUnexpectedEofError_base {
+}
+declare const BlobIntegrityError_base: Schema.Class<BlobIntegrityError, Schema.TaggedStruct<"BlobIntegrityError", {
+    readonly expectedDigest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly actualDigest: Schema.brand<Schema.String, "BlobDigest">;
+}>, import("effect/Cause").YieldableError>;
+/** Stored bytes no longer match their content address. */
+export declare class BlobIntegrityError extends BlobIntegrityError_base {
+}
+declare const BlobContainmentError_base: Schema.Class<BlobContainmentError, Schema.TaggedStruct<"BlobContainmentError", {
+    readonly operation: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A path escaped the owner-only object root or crossed a symbolic link. */
+export declare class BlobContainmentError extends BlobContainmentError_base {
+}
+declare const BlobStoreIoError_base: Schema.Class<BlobStoreIoError, Schema.TaggedStruct<"BlobStoreIoError", {
+    readonly operation: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The platform object-store operation failed. */
+export declare class BlobStoreIoError extends BlobStoreIoError_base {
+}
+/** Redacts platform details before they cross the object-store boundary. */
+export declare const blobStoreIoError: (operation: string, _cause: unknown) => BlobStoreIoError;
+/** Typed failures exposed by the blob-store boundary. */
+export type BlobStoreError = BlobContainmentError | BlobIntegrityError | BlobNotFoundError | BlobStoreInputError | BlobStoreIoError | BlobTooLargeError | BlobUnexpectedEofError;
+export {};
+//# sourceMappingURL=BlobStoreError.d.ts.map

package/dist/server/server/persistence/object-store/BlobStoreError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobStoreError.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/BlobStoreError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;AAI/B,4EAA4E;AAC5E,qBAAa,mBAAoB,SAAQ,wBAGvC;CAAG;;;;AAEL,mEAAmE;AACnE,qBAAa,iBAAkB,SAAQ,sBAErC;CAAG;;;;;;AAEL,6DAA6D;AAC7D,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;AAEL,2EAA2E;AAC3E,qBAAa,sBAAuB,SAAQ,2BAO3C;CAAG;;;;;AAEJ,0DAA0D;AAC1D,qBAAa,kBAAmB,SAAQ,uBAGtC;CAAG;;;;;AAEL,4EAA4E;AAC5E,qBAAa,oBAAqB,SAAQ,yBAMzC;CAAG;;;;;AAEJ,kDAAkD;AAClD,qBAAa,gBAAiB,SAAQ,qBAGpC;CAAG;AAEL,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,EAAE,QAAQ,OAAO,KAAG,gBACa,CAAA;AAEnF,yDAAyD;AACzD,MAAM,MAAM,cAAc,GACtB,oBAAoB,GACpB,kBAAkB,GAClB,iBAAiB,GACjB,mBAAmB,GACnB,gBAAgB,GAChB,iBAAiB,GACjB,sBAAsB,CAAA"}

package/dist/server/server/persistence/object-store/BlobStoreTypes.d.ts

@@ -0,0 +1,28 @@
+import type { Stream } from "effect";
+import type { BlobDigest } from "./BlobDigest.js";
+import type { BlobStoreError } from "./BlobStoreError.js";
+/** Optional bounded segment for stream and range reads. */
+export interface BlobRange {
+    readonly offset: number;
+    readonly length: number;
+}
+/** Metadata and bytes for a lazy file stream. */
+export interface BlobReadStream {
+    readonly digest: BlobDigest;
+    readonly sizeBytes: number;
+    readonly integrity: "not-verified";
+    readonly bytes: Stream.Stream<Uint8Array, BlobStoreError>;
+}
+/** Bounded range bytes; callers can separately request whole-object verification. */
+export interface BlobRangeRead {
+    readonly digest: BlobDigest;
+    readonly sizeBytes: number;
+    readonly integrity: "not-verified";
+    readonly bytes: Uint8Array;
+}
+/** Integrity-check result, independent of SQL durability metadata. */
+export interface BlobVerification {
+    readonly digest: BlobDigest;
+    readonly sizeBytes: number;
+}
+//# sourceMappingURL=BlobStoreTypes.d.ts.map

package/dist/server/server/persistence/object-store/BlobStoreTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlobStoreTypes.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/BlobStoreTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD,2DAA2D;AAC3D,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAA;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;CAC1D;AAED,qFAAqF;AACrF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAA;IAClC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAC3B;AAED,sEAAsE;AACtE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B"}

package/dist/server/server/persistence/object-store/OpenedBlob.d.ts

@@ -0,0 +1,21 @@
+import type { Path } from "effect";
+import { Effect, FileSystem, Stream } from "effect";
+import type { BlobDigest } from "./BlobDigest.js";
+import { BlobContainmentError, BlobNotFoundError } from "./BlobStoreError.js";
+import type { BlobStoreError } from "./BlobStoreError.js";
+/** Expected contained path and digest for an opened blob. */
+export interface BlobFileReference {
+    readonly digest: BlobDigest;
+    readonly filePath: string;
+}
+/** File identity captured from a verified descriptor. */
+export interface PinnedBlobLocation extends BlobFileReference {
+    readonly info: FileSystem.File.Info;
+}
+/** Builds descriptor-first readers around captured filesystem and path services. */
+export declare const makeOpenedBlobReader: (fs: FileSystem.FileSystem, path: Path.Path) => {
+    inspect: (operation: string, reference: BlobFileReference) => Effect.Effect<FileSystem.File.Info, BlobNotFoundError | BlobContainmentError | import("./BlobStoreError.js").BlobStoreIoError, never>;
+    read: (operation: string, location: PinnedBlobLocation, offset: number, length: number) => Effect.Effect<Uint8Array<ArrayBufferLike>, BlobStoreError, never>;
+    stream: (operation: string, location: PinnedBlobLocation, offset: number, length: number) => Stream.Stream<Uint8Array, BlobStoreError>;
+};
+//# sourceMappingURL=OpenedBlob.d.ts.map

package/dist/server/server/persistence/object-store/OpenedBlob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenedBlob.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/OpenedBlob.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAkB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAA4C,MAAM,qBAAqB,CAAA;AACvH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAKzD,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,yDAAyD;AACzD,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IAC3D,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAA;CACpC;AAoBD,oFAAoF;AACpF,eAAO,MAAM,oBAAoB,GAC/B,IAAI,UAAU,CAAC,UAAU,EACzB,MAAM,IAAI,CAAC,IAAI;;;wBA2FF,MAAM,YACP,kBAAkB,UACpB,MAAM,UACN,MAAM,KACb,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC;CA+B7C,CAAA"}

package/dist/server/server/persistence/object-store/PinnedDirectory.d.ts

@@ -0,0 +1,21 @@
+import type { FileSystem, Path } from "effect";
+import { Effect } from "effect";
+import { BlobContainmentError, blobStoreIoError } from "./BlobStoreError.js";
+/** Descriptor-backed directory alias used for containment-safe publication. */
+export interface PinnedDirectory {
+    readonly path: string;
+    readonly sync: Effect.Effect<void, ReturnType<typeof blobStoreIoError>>;
+    readonly assertIdentity: Effect.Effect<void, BlobContainmentError>;
+}
+/** Resolve a verified alias for the exact object already held by a descriptor. */
+export declare const resolveDescriptorAlias: (fs: FileSystem.FileSystem, path: Path.Path, descriptor: FileSystem.File.Descriptor, expectedPath: string, operation: string) => Effect.Effect<string, BlobContainmentError, never>;
+/**
+ * Pin an already validated directory and fail closed when the platform cannot
+ * address children through that exact descriptor.
+ */
+export declare const pinDirectory: (fs: FileSystem.FileSystem, path: Path.Path, directory: string) => Effect.Effect<{
+    path: string;
+    sync: Effect.Effect<void, import("./BlobStoreError.js").BlobStoreIoError, never>;
+    assertIdentity: Effect.Effect<void, BlobContainmentError, never>;
+}, BlobContainmentError | import("./BlobStoreError.js").BlobStoreIoError, import("effect/Scope").Scope>;
+//# sourceMappingURL=PinnedDirectory.d.ts.map

package/dist/server/server/persistence/object-store/PinnedDirectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PinnedDirectory.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/object-store/PinnedDirectory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAEvC,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAE5E,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAA;IACvE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAA;CACnE;AAOD,kFAAkF;AAClF,eAAO,MAAM,sBAAsB,qLAgBjC,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;uGA4BvB,CAAA"}

package/dist/server/server/persistence/repositories/agentJobModels.d.ts

@@ -0,0 +1,142 @@
+import * as Schema from "effect/Schema";
+/** Maximum persisted provider output across one attempt. */
+export declare const MAXIMUM_AGENT_ATTEMPT_OUTPUT_BYTES = 1048576;
+/**
+ * Maximum prompt characters accepted by durable enqueue.
+ *
+ * JSON may escape one UTF-16 code unit to six bytes. This conservative bound
+ * therefore keeps the complete `{ "prompt": ... }` event below 32 KiB.
+ */
+export declare const MAXIMUM_AGENT_JOB_PROMPT_LENGTH = 5000;
+/** Maximum thread events returned by one replay page. */
+export declare const MAXIMUM_AGENT_THREAD_EVENT_PAGE_SIZE = 128;
+/** Positive sequence assigned to attempts within one durable job. */
+export declare const AgentAttemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+export type AgentAttemptSequence = typeof AgentAttemptSequence.Type;
+/** Cursor used to request thread events after an already observed event. */
+export declare const AgentEventCursor: Schema.brand<Schema.Int, "AgentEventCursor">;
+export type AgentEventCursor = typeof AgentEventCursor.Type;
+/** Bounded replay-page size accepted by the repository. */
+export declare const AgentThreadEventPageSize: Schema.brand<Schema.Int, "AgentThreadEventPageSize">;
+export type AgentThreadEventPageSize = typeof AgentThreadEventPageSize.Type;
+/** Opaque worker identity retained with a durable claim. */
+export declare const AgentLeaseOwner: Schema.brand<Schema.String, "AgentLeaseOwner">;
+export type AgentLeaseOwner = typeof AgentLeaseOwner.Type;
+/** Secret bearer value proving ownership of one attempt lease. */
+export declare const AgentLeaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+export type AgentLeaseToken = typeof AgentLeaseToken.Type;
+/** Prompt guaranteed to fit the durable user-message event envelope. */
+export declare const AgentJobPrompt: Schema.String;
+export type AgentJobPrompt = typeof AgentJobPrompt.Type;
+/** Lifecycle state of one durable agent job. */
+export declare const AgentJobState: Schema.Literals<readonly ["queued", "running", "cancel-requested", "succeeded", "failed", "cancelled"]>;
+export type AgentJobState = typeof AgentJobState.Type;
+/** Immutable request persisted before a worker may claim it. */
+export declare const EnqueueAgentJobInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+    readonly providerId: Schema.brand<Schema.String, "AgentProviderId">;
+    readonly model: Schema.NullOr<Schema.String>;
+    readonly access: Schema.Literals<readonly ["read-only", "workspace-write"]>;
+    readonly prompt: Schema.String;
+    readonly contextFingerprint: Schema.brand<Schema.String, "AgentContextFingerprint">;
+    readonly subjectRevision: Schema.String;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+}>;
+export type EnqueueAgentJobInput = typeof EnqueueAgentJobInput.Type;
+/** Context frozen for one provider attempt. */
+export declare const AgentContextSnapshotRecord: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly subjectRevision: Schema.String;
+    readonly fingerprint: Schema.brand<Schema.String, "AgentContextFingerprint">;
+}>;
+export type AgentContextSnapshotRecord = typeof AgentContextSnapshotRecord.Type;
+/** Claimed work returned only after the lease and attempt are durable. */
+export declare const ClaimedAgentJob: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
+    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+    readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+    readonly leaseOwner: Schema.brand<Schema.String, "AgentLeaseOwner">;
+    readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+    readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
+    readonly providerId: Schema.brand<Schema.String, "AgentProviderId">;
+    readonly model: Schema.NullOr<Schema.String>;
+    readonly access: Schema.Literals<readonly ["read-only", "workspace-write"]>;
+    readonly prompt: Schema.String;
+    readonly context: Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly subjectRevision: Schema.String;
+        readonly fingerprint: Schema.brand<Schema.String, "AgentContextFingerprint">;
+    }>;
+    readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
+    readonly cancellationRequested: Schema.Boolean;
+}>;
+export type ClaimedAgentJob = typeof ClaimedAgentJob.Type;
+/**
+ * Identity and expiration used to claim or reclaim one queued job.
+ *
+ * `claimedAt` is caller-reported context only; repository clock time owns
+ * lease eligibility and the durable acquisition timestamp.
+ */
+export declare const ClaimAgentJobInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly leaseOwner: Schema.brand<Schema.String, "AgentLeaseOwner">;
+    readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+    readonly claimedAt: Schema.DateTimeUtcFromString;
+    readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
+}>;
+export type ClaimAgentJobInput = typeof ClaimAgentJobInput.Type;
+/** Provider event persisted under an active attempt lease. */
+export declare const AppendAgentEventInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+    readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+    readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+    readonly event: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"started", {
+        readonly providerRunRef: Schema.NullOr<Schema.String>;
+        readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
+    }>, Schema.TaggedStruct<"output", {
+        readonly channel: Schema.Literals<readonly ["assistant", "progress"]>;
+        readonly text: Schema.String;
+    }>, Schema.TaggedStruct<"usage", {
+        readonly inputTokens: Schema.Int;
+        readonly outputTokens: Schema.Int;
+    }>, Schema.TaggedStruct<"completed", {
+        readonly outcome: Schema.Literals<readonly ["success", "cancelled", "max-steps"]>;
+        readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
+    }>]>;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+}>;
+export type AppendAgentEventInput = typeof AppendAgentEventInput.Type;
+/** One immutable event in a release thread. */
+export declare const AgentThreadEvent: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
+    readonly eventSequence: Schema.brand<Schema.Int, "AgentEventCursor">;
+    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+    readonly attemptSequence: Schema.NullOr<Schema.brand<Schema.Int, "AgentAttemptSequence">>;
+    readonly eventKind: Schema.Literals<readonly ["user-message", "job-queued", "job-started", "assistant-output", "progress", "usage", "job-completed", "job-failed", "cancel-requested"]>;
+    readonly payload: Schema.Unknown;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+}>;
+export type AgentThreadEvent = typeof AgentThreadEvent.Type;
+/** Ordered bounded replay page for one release thread. */
+export interface AgentThreadEventPage {
+    readonly events: ReadonlyArray<AgentThreadEvent>;
+    readonly nextCursor: AgentEventCursor;
+}
+declare const AgentJobInputError_base: Schema.Class<AgentJobInputError, Schema.TaggedStruct<"AgentJobInputError", {
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+    readonly reason: Schema.Literals<readonly ["invalid-transition", "lease-lost", "lease-expired", "output-limit-exceeded", "event-limit-exceeded"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Stable typed failure for invalid job state, lease, or bounded output. */
+export declare class AgentJobInputError extends AgentJobInputError_base {
+}
+export {};
+//# sourceMappingURL=agentJobModels.d.ts.map

package/dist/server/server/persistence/repositories/agentJobModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentJobModels.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/agentJobModels.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,4DAA4D;AAC5D,eAAO,MAAM,kCAAkC,UAAY,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,OAAQ,CAAA;AAEpD,yDAAyD;AACzD,eAAO,MAAM,oCAAoC,MAAM,CAAA;AAEvD,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,kDAEW,CAAA;AAC5C,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,8CAEW,CAAA;AACxC,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,2DAA2D;AAC3D,eAAO,MAAM,wBAAwB,sDAEW,CAAA;AAChD,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAC,IAAI,CAAA;AAE3E,4DAA4D;AAC5D,eAAO,MAAM,eAAe,gDAIW,CAAA;AACvC,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AAEzD,kEAAkE;AAClE,eAAO,MAAM,eAAe,gDAEW,CAAA;AACvC,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AAYzD,wEAAwE;AACxE,eAAO,MAAM,cAAc,eAG1B,CAAA;AACD,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD,gDAAgD;AAChD,eAAO,MAAM,aAAa,yGAOxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,gEAAgE;AAChE,eAAO,MAAM,oBAAoB;;;;;;;;;;;EAW/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,+CAA+C;AAC/C,eAAO,MAAM,0BAA0B;;;;;EAKrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA;AAE/E,0EAA0E;AAC1E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;EAgB1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;EAM7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA;AAE/D,8DAA8D;AAC9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;EAOhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAA;AAErE,+CAA+C;AAC/C,eAAO,MAAM,gBAAgB;;;;;;;;;EAmB3B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,0DAA0D;AAC1D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAA;IAChD,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAA;CACtC;;;;;;AAED,4EAA4E;AAC5E,qBAAa,kBAAmB,SAAQ,uBAavC;CAAG"}

package/dist/server/server/persistence/repositories/agentJobRepository.d.ts

@@ -0,0 +1,134 @@
+/** Durable release-thread job claiming, event persistence, and replay. @module */
+import { AgentProviderError } from "@knpkv/ai-runtime";
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { Database } from "../Database.js";
+import { PersistedRecordError, PersistenceOperationError, RecordNotFoundError } from "../errors.js";
+import { AgentJobInputError } from "./agentJobModels.js";
+declare const makeAgentJobRepository: Effect.Effect<{
+    enqueue: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly providerId: Schema.brand<Schema.String, "AgentProviderId">;
+        readonly model: Schema.NullOr<Schema.String>;
+        readonly access: Schema.Literals<readonly ["read-only", "workspace-write"]>;
+        readonly prompt: Schema.String;
+        readonly contextFingerprint: Schema.brand<Schema.String, "AgentContextFingerprint">;
+        readonly subjectRevision: Schema.String;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<string & import("effect/Brand").Brand<"AgentThreadId">, Schema.SchemaError | RecordNotFoundError | import("../errors.js").RecordAlreadyExistsError | PersistenceOperationError | PersistedRecordError | AgentJobInputError, never>;
+    claimNext: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly leaseOwner: Schema.brand<Schema.String, "AgentLeaseOwner">;
+        readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+        readonly claimedAt: Schema.DateTimeUtcFromString;
+        readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<Option.Option<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        readonly leaseOwner: Schema.brand<Schema.String, "AgentLeaseOwner">;
+        readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+        readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
+        readonly providerId: Schema.brand<Schema.String, "AgentProviderId">;
+        readonly model: Schema.NullOr<Schema.String>;
+        readonly access: Schema.Literals<readonly ["read-only", "workspace-write"]>;
+        readonly prompt: Schema.String;
+        readonly context: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly subjectRevision: Schema.String;
+            readonly fingerprint: Schema.brand<Schema.String, "AgentContextFingerprint">;
+        }>;
+        readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
+        readonly cancellationRequested: Schema.Boolean;
+    }, "Type">>, Schema.SchemaError | PersistenceOperationError | PersistedRecordError | AgentJobInputError, never>;
+    appendEvent: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+        readonly event: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"started", {
+            readonly providerRunRef: Schema.NullOr<Schema.String>;
+            readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
+        }>, Schema.TaggedStruct<"output", {
+            readonly channel: Schema.Literals<readonly ["assistant", "progress"]>;
+            readonly text: Schema.String;
+        }>, Schema.TaggedStruct<"usage", {
+            readonly inputTokens: Schema.Int;
+            readonly outputTokens: Schema.Int;
+        }>, Schema.TaggedStruct<"completed", {
+            readonly outcome: Schema.Literals<readonly ["success", "cancelled", "max-steps"]>;
+            readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
+        }>]>;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
+        readonly eventSequence: Schema.brand<Schema.Int, "AgentEventCursor">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.NullOr<Schema.brand<Schema.Int, "AgentAttemptSequence">>;
+        readonly eventKind: Schema.Literals<readonly ["user-message", "job-queued", "job-started", "assistant-output", "progress", "usage", "job-completed", "job-failed", "cancel-requested"]>;
+        readonly payload: Schema.Unknown;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+    }, "Type">, unknown, never>;
+    failAttempt: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+        readonly error: typeof AgentProviderError;
+        readonly failedAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
+        readonly eventSequence: Schema.brand<Schema.Int, "AgentEventCursor">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.NullOr<Schema.brand<Schema.Int, "AgentAttemptSequence">>;
+        readonly eventKind: Schema.Literals<readonly ["user-message", "job-queued", "job-started", "assistant-output", "progress", "usage", "job-completed", "job-failed", "cancel-requested"]>;
+        readonly payload: Schema.Unknown;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+    }, "Type">, unknown, never>;
+    requestCancellation: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly requestedAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<void, unknown, never>;
+    threadAfter: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly after: Schema.brand<Schema.Int, "AgentEventCursor">;
+        readonly limit: Schema.brand<Schema.Int, "AgentThreadEventPageSize">;
+    }, "Type">) => Effect.Effect<{
+        events: Schema.Struct.ReadonlySide<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
+            readonly eventSequence: Schema.brand<Schema.Int, "AgentEventCursor">;
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+            readonly attemptSequence: Schema.NullOr<Schema.brand<Schema.Int, "AgentAttemptSequence">>;
+            readonly eventKind: Schema.Literals<readonly ["user-message", "job-queued", "job-started", "assistant-output", "progress", "usage", "job-completed", "job-failed", "cancel-requested"]>;
+            readonly payload: Schema.Unknown;
+            readonly occurredAt: Schema.DateTimeUtcFromString;
+        }, "Type">[];
+        nextCursor: number & import("effect/Brand").Brand<"AgentEventCursor">;
+    }, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError, never>;
+}, never, Crypto.Crypto | Database>;
+/** Durable release-thread repository with transactional worker ownership. */
+export interface AgentJobRepositoryService extends Success<typeof makeAgentJobRepository> {
+}
+declare const AgentJobRepository_base: Context.ServiceClass<AgentJobRepository, "@knpkv/control-center/AgentJobRepository", AgentJobRepositoryService>;
+/** Effect service owning durable agent job lifecycle and ordered replay. */
+export declare class AgentJobRepository extends AgentJobRepository_base {
+    /** Layer that captures the shared SQLite database and cryptography services. */
+    static readonly layer: Layer.Layer<AgentJobRepository, never, Crypto.Crypto | Database>;
+}
+export {};
+//# sourceMappingURL=agentJobRepository.d.ts.map

package/dist/server/server/persistence/repositories/agentJobRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentJobRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/agentJobRepository.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,OAAO,EAAE,kBAAkB,EAAqB,MAAM,mBAAmB,CAAA;AAOzE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACnG,OAAO,EAIL,kBAAkB,EAUnB,MAAM,qBAAqB,CAAA;AAgI5B,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAg0B1B,CAAA;AAEF,6EAA6E;AAC7E,MAAM,WAAW,yBAA0B,SAAQ,OAAO,CAAC,OAAO,sBAAsB,CAAC;CAAG;;AAE5F,4EAA4E;AAC5E,qBAAa,kBAAmB,SAAQ,uBAEvC;IACC,gFAAgF;IAChF,MAAM,CAAC,QAAQ,CAAC,KAAK,mEAA2D;CACjF"}

package/dist/server/server/persistence/repositories/authorizedShareRepository.d.ts

@@ -0,0 +1,92 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Database } from "../Database.js";
+import { RecordAlreadyExistsError, RecordNotFoundError } from "../errors.js";
+declare const AuthorizedShareInputError_base: Schema.Class<AuthorizedShareInputError, Schema.TaggedStruct<"AuthorizedShareInputError", {
+    readonly operation: Schema.Literals<readonly ["create", "get", "revoke"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when authorized-share persistence input fails boundary decoding. */
+export declare class AuthorizedShareInputError extends AuthorizedShareInputError_base {
+}
+/** Immutable owner-authored exact-entity share grant. */
+export declare const CreateAuthorizedShareInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly shareId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ShareId">;
+    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+    readonly granteePersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+    readonly createdByPersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+    readonly createdBySessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded authorized-share creation command. */
+export type CreateAuthorizedShareInput = typeof CreateAuthorizedShareInput.Type;
+/** Workspace-scoped authorized-share lookup. */
+export declare const ReadAuthorizedShareInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly shareId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ShareId">;
+}>;
+/** Immutable owner-authored share revocation. */
+export declare const RevokeAuthorizedShareInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly shareId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ShareId">;
+    readonly revokedByPersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+    readonly revokedBySessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    readonly revokedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded authorized-share revocation command. */
+export type RevokeAuthorizedShareInput = typeof RevokeAuthorizedShareInput.Type;
+declare const makeAuthorizedShareRepository: Effect.Effect<{
+    create: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly shareId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ShareId">;
+        readonly target: Schema.TaggedStruct<"entity", {
+            readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        }>;
+        readonly granteePersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly createdByPersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly createdBySessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly expiresAt: Schema.DateTimeUtcFromString;
+        readonly revokedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, RecordNotFoundError | RecordAlreadyExistsError | import("../errors.js").PersistenceOperationError | AuthorizedShareInputError, never>;
+    get: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly shareId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ShareId">;
+        readonly target: Schema.TaggedStruct<"entity", {
+            readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        }>;
+        readonly granteePersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly createdByPersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly createdBySessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly expiresAt: Schema.DateTimeUtcFromString;
+        readonly revokedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, RecordNotFoundError | import("../errors.js").PersistenceOperationError | AuthorizedShareInputError, never>;
+    revoke: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly shareId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ShareId">;
+        readonly target: Schema.TaggedStruct<"entity", {
+            readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        }>;
+        readonly granteePersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly createdByPersonId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly createdBySessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly expiresAt: Schema.DateTimeUtcFromString;
+        readonly revokedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, RecordNotFoundError | import("../errors.js").PersistenceOperationError | AuthorizedShareInputError, never>;
+}, never, Database>;
+/** Durable exact-scope authorized-share repository service. */
+export interface AuthorizedShareRepositoryService extends Success<typeof makeAuthorizedShareRepository> {
+}
+declare const AuthorizedShareRepository_base: Context.ServiceClass<AuthorizedShareRepository, "@knpkv/control-center/server/persistence/AuthorizedShareRepository", AuthorizedShareRepositoryService>;
+/** Private authorized-share SQL repository. */
+export declare class AuthorizedShareRepository extends AuthorizedShareRepository_base {
+    static readonly layer: Layer.Layer<AuthorizedShareRepository, never, Database>;
+}
+export {};
+//# sourceMappingURL=authorizedShareRepository.d.ts.map

package/dist/server/server/persistence/repositories/authorizedShareRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorizedShareRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/authorizedShareRepository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAEzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;;;;AAK5E,8EAA8E;AAC9E,qBAAa,yBAA0B,SAAQ,8BAG9C;CAAG;AAEJ,yDAAyD;AACzD,eAAO,MAAM,0BAA0B;;;;;;;;;EASrC,CAAA;AAEF,iDAAiD;AACjD,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA;AAE/E,gDAAgD;AAChD,eAAO,MAAM,wBAAwB;;;EAGnC,CAAA;AAEF,iDAAiD;AACjD,eAAO,MAAM,0BAA0B;;;;;;EAMrC,CAAA;AAEF,mDAAmD;AACnD,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA;AAkD/E,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAwFjC,CAAA;AAEF,+DAA+D;AAC/D,MAAM,WAAW,gCAAiC,SAAQ,OAAO,CAAC,OAAO,6BAA6B,CAAC;CAAG;;AAE1G,+CAA+C;AAC/C,qBAAa,yBAA0B,SAAQ,8BAG0B;IACvE,MAAM,CAAC,QAAQ,CAAC,KAAK,0DAAyE;CAC/F"}