@boboddy/sdk 0.0.11-alpha → 0.0.13-alpha

package/dist/packages/core/src/pipeline-executions/step-execution/application/complete-claimed-step-execution.d.ts

@@ -1,39 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
-import { Result } from "@boboddy/core/lib/result";
-import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
-import type { LinearPipelineExecutionRepo } from "@boboddy/core/pipeline-executions/pipeline-execution/application/linear-pipeline-execution-repo";
-import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
-import { type CompleteClaimedStepExecutionInput, type GetStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const completeClaimedStepExecution: (stepExecutionIdInput: GetStepExecutionInput, input: CompleteClaimedStepExecutionInput, { userAuthz, stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
-    userAuthz: UserAuthorizationService;
-    stepExecutionRepo: StepExecutionRepo;
-    stepDefinitionRepo: StepDefinitionRepo;
-    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
-    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
-    timeProvider: TimeProvider;
-    domainEventDispatcher?: InMemoryDomainEventDispatcher;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<Result<StepExecutionContract, ResourceNotFoundError>>;
-export declare const failTimedOutStepExecution: (stepExecutionIdInput: GetStepExecutionInput, { stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
-    stepExecutionRepo: StepExecutionRepo;
-    stepDefinitionRepo: StepDefinitionRepo;
-    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
-    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
-    timeProvider: TimeProvider;
-    domainEventDispatcher?: InMemoryDomainEventDispatcher;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<Result<StepExecutionContract, ResourceNotFoundError>>;
-export declare const failAbandonedStepExecution: (stepExecutionIdInput: GetStepExecutionInput, { stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
-    stepExecutionRepo: StepExecutionRepo;
-    stepDefinitionRepo: StepDefinitionRepo;
-    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
-    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
-    timeProvider: TimeProvider;
-    domainEventDispatcher?: InMemoryDomainEventDispatcher;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<Result<StepExecutionContract, ResourceNotFoundError>>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/create-step-execution.d.ts

@@ -1,11 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import { type CreateStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const createStepExecution: (input: CreateStepExecutionInput, { userAuthz, stepExecutionRepo, timeProvider, dbExecutor, }: {
-    userAuthz: UserAuthorizationService;
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepExecutionContract>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/extract-step-execution-signals.d.ts

@@ -1,17 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import { CoreValidationError, ResourceNotFoundError } from "@boboddy/core/lib/errors";
-import { Result } from "@boboddy/core/lib/result";
-import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
-import { type GetStepExecutionResultInput, type StepSignalContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const extractStepExecutionSignals: (input: GetStepExecutionResultInput, { userAuthz, stepDefinitionRepo, stepExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
-    userAuthz?: UserAuthorizationService;
-    stepDefinitionRepo: StepDefinitionRepo;
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    domainEventDispatcher?: InMemoryDomainEventDispatcher;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<Result<StepSignalContract[], ResourceNotFoundError | CoreValidationError>>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/get-step-execution-worker-context.d.ts

@@ -1,17 +0,0 @@
-import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-import { Result } from "@boboddy/core/lib/result";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import type { ProjectRepo } from "@boboddy/core/projects/project/application/project-repo";
-import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
-import type { ProjectContextEntryRepo } from "@boboddy/core/projects/project-context/application/project-context-entry-repo";
-import { type GetStepExecutionInput, type GetStepExecutionWorkerContextInput, type StepExecutionWorkerContextContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const getStepExecutionWorkerContext: (stepExecutionIdInput: GetStepExecutionInput, input: GetStepExecutionWorkerContextInput, { userAuthz, projectRepo, stepExecutionRepo, stepDefinitionRepo, projectContextEntryRepo, timeProvider, }: {
-    userAuthz: UserAuthorizationService;
-    projectRepo: ProjectRepo;
-    stepExecutionRepo: StepExecutionRepo;
-    stepDefinitionRepo: StepDefinitionRepo;
-    projectContextEntryRepo: ProjectContextEntryRepo;
-    timeProvider: TimeProvider;
-}) => Promise<Result<StepExecutionWorkerContextContract, ResourceNotFoundError>>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/get-step-execution.d.ts

@@ -1,13 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
-import { Result } from "@boboddy/core/lib/result";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import { type GetStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-export declare const getStepExecution: (input: GetStepExecutionInput, { userAuthz, stepExecutionRepo, timeProvider, dbExecutor, }: {
-    userAuthz: UserAuthorizationService;
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<Result<StepExecutionContract, ResourceNotFoundError>>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/heartbeat-step-execution-claim.d.ts

@@ -1,21 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
-import { Result } from "@boboddy/core/lib/result";
-import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
-import type { LinearPipelineExecutionRepo } from "@boboddy/core/pipeline-executions/pipeline-execution/application/linear-pipeline-execution-repo";
-import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
-import { type GetStepExecutionInput, type StepExecutionClaimCommandInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const heartbeatStepExecutionClaim: (stepExecutionIdInput: GetStepExecutionInput, input: StepExecutionClaimCommandInput, { userAuthz, stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
-    userAuthz: UserAuthorizationService;
-    stepExecutionRepo: StepExecutionRepo;
-    stepDefinitionRepo: StepDefinitionRepo;
-    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
-    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
-    timeProvider: TimeProvider;
-    domainEventDispatcher?: InMemoryDomainEventDispatcher;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<Result<StepExecutionContract, ResourceNotFoundError>>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/list-step-executions-by-project.d.ts

@@ -1,11 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import { type ListStepExecutionsByProjectIdInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-export declare const listStepExecutionsByProjectId: (input: ListStepExecutionsByProjectIdInput, { userAuthz, stepExecutionRepo, timeProvider, dbExecutor, }: {
-    userAuthz: UserAuthorizationService;
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepExecutionContract[]>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/load-status-adjusted-step-executions.d.ts

@@ -1,31 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
-import type { StepExecutionEntity } from "../domain/step-execution-entity";
-import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const loadStatusAdjustedStepExecution: (stepExecutionId: UuidV7, { stepExecutionRepo, timeProvider, dbExecutor, }: {
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepExecutionEntity | null>;
-export declare const loadStatusAdjustedStepExecutionsByIds: (stepExecutionIds: UuidV7[], { stepExecutionRepo, timeProvider, dbExecutor, }: {
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<(StepExecutionEntity | null)[]>;
-export declare const loadStatusAdjustedStepExecutionByResultId: (stepExecutionResultId: UuidV7, { stepExecutionRepo, timeProvider, dbExecutor, }: {
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepExecutionEntity | null>;
-export declare const listStatusAdjustedStepExecutionsByProjectId: (projectId: UuidV7, { stepExecutionRepo, timeProvider, dbExecutor, }: {
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepExecutionEntity[]>;
-export declare const loadStatusAdjustedClaimableStepExecutionsByProjectId: (projectId: UuidV7, limit: number, now: Date, { stepExecutionRepo, timeProvider, dbExecutor, workItemId, }: {
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-    workItemId?: string | undefined;
-}) => Promise<StepExecutionEntity[]>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/mark-step-execution-running.d.ts

@@ -1,13 +0,0 @@
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
-import type { TimeProvider } from "@boboddy/core/lib/time-provider";
-import { Result } from "@boboddy/core/lib/result";
-import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
-import { type GetStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const markStepExecutionRunning: (input: GetStepExecutionInput, { userAuthz, stepExecutionRepo, timeProvider, dbExecutor, }: {
-    userAuthz: UserAuthorizationService;
-    stepExecutionRepo: StepExecutionRepo;
-    timeProvider: TimeProvider;
-    dbExecutor?: DbExecutor | undefined;
-}) => Promise<Result<StepExecutionContract, ResourceNotFoundError>>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/step-execution-claim-helpers.d.ts

@@ -1,13 +0,0 @@
-import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
-import type { StepExecutionEntity } from "../domain/step-execution-entity";
-export declare const buildLeaseExpiresAt: (now: Date, leaseDurationSeconds: number) => Date;
-export declare const buildExecutionDeadlineAt: (stepExecution: StepExecutionEntity, now: Date) => Date | null;
-export declare const buildTimedOutStepExecutionResult: (stepExecution: StepExecutionEntity, now: Date) => {
-    resultJson: AnyJsonValue;
-    errorJson: AnyJsonValue;
-};
-export declare const buildAbandonedStepExecutionResult: (stepExecution: StepExecutionEntity, now: Date) => {
-    resultJson: AnyJsonValue;
-    errorJson: AnyJsonValue;
-};
-export declare const assertClaimOwnership: (stepExecution: StepExecutionEntity, claimToken: string, now: Date) => void;

package/dist/packages/core/src/pipeline-executions/step-execution/application/step-execution-contract-mapper.d.ts

@@ -1,7 +0,0 @@
-import type { StepExecutionContract, StepExecutionResultContract, StepSignalContract } from "../contracts/step-execution-contracts";
-import type { StepExecutionEntity } from "../domain/step-execution-entity";
-import type { StepExecutionResultEntity } from "../entities/step-execution-result-entity";
-import type { StepSignalEntity } from "../entities/step-signal-entity";
-export declare const stepSignalEntityToContract: (signal: StepSignalEntity) => StepSignalContract;
-export declare const stepExecutionResultEntityToContract: (result: StepExecutionResultEntity) => StepExecutionResultContract;
-export declare const stepExecutionEntityToContract: (stepExecution: StepExecutionEntity) => StepExecutionContract;

package/dist/packages/core/src/pipeline-executions/step-execution/application/step-execution-repo.d.ts

@@ -1,29 +0,0 @@
-import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
-import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
-import type { StepExecutionEntity } from "../domain/step-execution-entity";
-import type { StepExecutionResultEntity } from "../entities/step-execution-result-entity";
-import type { StepSignalEntity } from "../entities/step-signal-entity";
-export type StepExecutionRepo = {
-    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
-    loadMany(ids: UuidV7[], dbExecutor?: DbExecutor): Promise<(StepExecutionEntity | null)[]>;
-    loadByResultId(stepExecutionResultId: UuidV7, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
-    listByProjectId(projectId: UuidV7, dbExecutor?: DbExecutor): Promise<StepExecutionEntity[]>;
-    loadClaimableByProjectId(projectId: UuidV7, limit: number, now: Date, dbExecutor?: DbExecutor, workItemId?: string): Promise<StepExecutionEntity[]>;
-    create(stepExecution: StepExecutionEntity, dbExecutor?: DbExecutor): Promise<StepExecutionEntity>;
-    claim(stepExecutionId: UuidV7, claim: {
-        workerId: string;
-        claimToken: string;
-        claimedAt: Date;
-        startedAt: Date;
-        leaseExpiresAt: Date;
-        executionDeadlineAt?: Date | null | undefined;
-    }, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
-    heartbeat(stepExecutionId: UuidV7, claimToken: string, heartbeat: {
-        lastHeartbeatAt: Date;
-        leaseExpiresAt: Date;
-    }, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
-    save(stepExecution: StepExecutionEntity, dbExecutor?: DbExecutor): Promise<StepExecutionEntity>;
-    saveMany(stepExecutions: StepExecutionEntity[], dbExecutor?: DbExecutor): Promise<StepExecutionEntity[]>;
-    addResult(stepExecutionResult: StepExecutionResultEntity, dbExecutor?: DbExecutor): Promise<StepExecutionResultEntity>;
-    replaceSignals(stepExecutionResultId: UuidV7, signals: StepSignalEntity[], dbExecutor?: DbExecutor): Promise<StepSignalEntity[]>;
-};

package/dist/packages/core/src/pipeline-executions/step-execution/contracts/step-execution-contracts.d.ts

@@ -1,325 +0,0 @@
-import { z } from "zod";
-export declare const stepSignalSchema: z.ZodObject<{
-    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    key: z.ZodString;
-    type: z.ZodEnum<{
-        string: "string";
-        number: "number";
-        boolean: "boolean";
-        object: "object";
-        array: "array";
-    }>;
-    source: z.ZodEnum<{
-        extracted: "extracted";
-        computed: "computed";
-    }>;
-    valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-    sourcePath: z.ZodNullable<z.ZodString>;
-    computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
-    createdAt: z.ZodISODateTime;
-}, z.core.$strip>;
-export declare const stepExecutionResultSchema: z.ZodObject<{
-    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    attempt: z.ZodNumber;
-    status: z.ZodEnum<{
-        succeeded: "succeeded";
-        failed: "failed";
-    }>;
-    resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-    errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-    signals: z.ZodArray<z.ZodObject<{
-        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        key: z.ZodString;
-        type: z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            object: "object";
-            array: "array";
-        }>;
-        source: z.ZodEnum<{
-            extracted: "extracted";
-            computed: "computed";
-        }>;
-        valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-        sourcePath: z.ZodNullable<z.ZodString>;
-        computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strip>>;
-    createdAt: z.ZodISODateTime;
-}, z.core.$strip>;
-export declare const stepExecutionSchema: z.ZodObject<{
-    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    stepDefinitionVersion: z.ZodNumber;
-    status: z.ZodEnum<{
-        queued: "queued";
-        running: "running";
-        succeeded: "succeeded";
-        failed: "failed";
-        cancelled: "cancelled";
-        skipped: "skipped";
-        timeout: "timeout";
-        abandoned: "abandoned";
-    }>;
-    inputJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-    claimedBy: z.ZodNullable<z.ZodString>;
-    claimedAt: z.ZodNullable<z.ZodISODateTime>;
-    lastHeartbeatAt: z.ZodNullable<z.ZodISODateTime>;
-    leaseExpiresAt: z.ZodNullable<z.ZodISODateTime>;
-    executionTimeoutSeconds: z.ZodNullable<z.ZodNumber>;
-    executionDeadlineAt: z.ZodNullable<z.ZodISODateTime>;
-    startedAt: z.ZodNullable<z.ZodISODateTime>;
-    completedAt: z.ZodNullable<z.ZodISODateTime>;
-    results: z.ZodArray<z.ZodObject<{
-        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        attempt: z.ZodNumber;
-        status: z.ZodEnum<{
-            succeeded: "succeeded";
-            failed: "failed";
-        }>;
-        resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-        errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-        signals: z.ZodArray<z.ZodObject<{
-            id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-            stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-            key: z.ZodString;
-            type: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                object: "object";
-                array: "array";
-            }>;
-            source: z.ZodEnum<{
-                extracted: "extracted";
-                computed: "computed";
-            }>;
-            valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-            sourcePath: z.ZodNullable<z.ZodString>;
-            computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
-            createdAt: z.ZodISODateTime;
-        }, z.core.$strip>>;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strip>>;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-}, z.core.$strip>;
-export declare const createStepExecutionInputSchema: z.ZodObject<{
-    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    stepDefinitionVersion: z.ZodNumber;
-    inputJson: z.ZodOptional<z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>>;
-    status: z.ZodOptional<z.ZodEnum<{
-        queued: "queued";
-        running: "running";
-        succeeded: "succeeded";
-        failed: "failed";
-        cancelled: "cancelled";
-        skipped: "skipped";
-        timeout: "timeout";
-        abandoned: "abandoned";
-    }>>;
-    executionTimeoutSeconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-}, z.core.$strip>;
-export declare const stepExecutionClaimSchema: z.ZodObject<{
-    stepExecution: z.ZodObject<{
-        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        stepDefinitionVersion: z.ZodNumber;
-        status: z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            succeeded: "succeeded";
-            failed: "failed";
-            cancelled: "cancelled";
-            skipped: "skipped";
-            timeout: "timeout";
-            abandoned: "abandoned";
-        }>;
-        inputJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-        claimedBy: z.ZodNullable<z.ZodString>;
-        claimedAt: z.ZodNullable<z.ZodISODateTime>;
-        lastHeartbeatAt: z.ZodNullable<z.ZodISODateTime>;
-        leaseExpiresAt: z.ZodNullable<z.ZodISODateTime>;
-        executionTimeoutSeconds: z.ZodNullable<z.ZodNumber>;
-        executionDeadlineAt: z.ZodNullable<z.ZodISODateTime>;
-        startedAt: z.ZodNullable<z.ZodISODateTime>;
-        completedAt: z.ZodNullable<z.ZodISODateTime>;
-        results: z.ZodArray<z.ZodObject<{
-            id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-            stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-            attempt: z.ZodNumber;
-            status: z.ZodEnum<{
-                succeeded: "succeeded";
-                failed: "failed";
-            }>;
-            resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-            errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-            signals: z.ZodArray<z.ZodObject<{
-                id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-                stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-                key: z.ZodString;
-                type: z.ZodEnum<{
-                    string: "string";
-                    number: "number";
-                    boolean: "boolean";
-                    object: "object";
-                    array: "array";
-                }>;
-                source: z.ZodEnum<{
-                    extracted: "extracted";
-                    computed: "computed";
-                }>;
-                valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-                sourcePath: z.ZodNullable<z.ZodString>;
-                computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
-                createdAt: z.ZodISODateTime;
-            }, z.core.$strip>>;
-            createdAt: z.ZodISODateTime;
-        }, z.core.$strip>>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-    }, z.core.$strip>;
-    claimToken: z.ZodString;
-}, z.core.$strip>;
-export declare const claimStepExecutionsInputSchema: z.ZodObject<{
-    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    workerId: z.ZodString;
-    batchSize: z.ZodDefault<z.ZodNumber>;
-    leaseDurationSeconds: z.ZodDefault<z.ZodNumber>;
-    workItemId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const stepExecutionClaimCommandInputSchema: z.ZodObject<{
-    claimToken: z.ZodString;
-    leaseDurationSeconds: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const getStepExecutionWorkerContextInputSchema: z.ZodObject<{
-    claimToken: z.ZodString;
-}, z.core.$strip>;
-export declare const stepExecutionWorkerContextSchema: z.ZodObject<{
-    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    gitUrl: z.ZodString;
-    requestedBranch: z.ZodNullable<z.ZodString>;
-    projectOpencodeConfig: z.ZodObject<{
-        relativePath: z.ZodString;
-        present: z.ZodBoolean;
-        commands: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodString;
-            run: z.ZodString;
-            cwd: z.ZodNullable<z.ZodString>;
-        }, z.core.$strip>>;
-        services: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodString;
-            run: z.ZodString;
-            cwd: z.ZodNullable<z.ZodString>;
-            dependsOn: z.ZodArray<z.ZodString>;
-            expose: z.ZodObject<{
-                targetPort: z.ZodNumber;
-                protocol: z.ZodEnum<{
-                    tcp: "tcp";
-                    http: "http";
-                }>;
-            }, z.core.$strip>;
-            healthcheck: z.ZodObject<{
-                protocol: z.ZodEnum<{
-                    tcp: "tcp";
-                    http: "http";
-                }>;
-                path: z.ZodNullable<z.ZodString>;
-                expectedStatus: z.ZodNullable<z.ZodNumber>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    stepExecution: z.ZodObject<{
-        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        status: z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            succeeded: "succeeded";
-            failed: "failed";
-            cancelled: "cancelled";
-            skipped: "skipped";
-            timeout: "timeout";
-            abandoned: "abandoned";
-        }>;
-        inputJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-        executionTimeoutSeconds: z.ZodNullable<z.ZodNumber>;
-    }, z.core.$strip>;
-    stepDefinition: z.ZodObject<{
-        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-        key: z.ZodString;
-        name: z.ZodString;
-        prompt: z.ZodString;
-        resultSchemaJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
-        opencodeMcpJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-            type: z.ZodLiteral<"local">;
-            command: z.ZodArray<z.ZodString>;
-            environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            timeout: z.ZodOptional<z.ZodInt>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"remote">;
-            url: z.ZodString;
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            oauth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-                clientId: z.ZodOptional<z.ZodString>;
-                clientSecret: z.ZodOptional<z.ZodString>;
-                scope: z.ZodOptional<z.ZodString>;
-                redirectUri: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>, z.ZodLiteral<false>]>>;
-            timeout: z.ZodOptional<z.ZodInt>;
-        }, z.core.$strict>, z.ZodObject<{
-            enabled: z.ZodBoolean;
-        }, z.core.$strict>]>>>;
-    }, z.core.$strip>;
-    agentPrompt: z.ZodObject<{
-        sessionTitle: z.ZodString;
-        promptText: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const completeClaimedStepExecutionInputSchema: z.ZodObject<{
-    claimToken: z.ZodString;
-    status: z.ZodEnum<{
-        succeeded: "succeeded";
-        failed: "failed";
-    }>;
-    resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-    errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-}, z.core.$strip>;
-export declare const addStepExecutionResultInputSchema: z.ZodObject<{
-    status: z.ZodEnum<{
-        succeeded: "succeeded";
-        failed: "failed";
-    }>;
-    stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-    attempt: z.ZodNumber;
-    resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
-    errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
-}, z.core.$strip>;
-export declare const getStepExecutionInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-export declare const getStepExecutionResultInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-export declare const listStepExecutionsByProjectIdInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
-export type StepSignalContract = z.infer<typeof stepSignalSchema>;
-export type StepExecutionResultContract = z.infer<typeof stepExecutionResultSchema>;
-export type StepExecutionContract = z.infer<typeof stepExecutionSchema>;
-export type StepExecutionClaimContract = z.infer<typeof stepExecutionClaimSchema>;
-export type CreateStepExecutionInput = z.input<typeof createStepExecutionInputSchema>;
-export type AddStepExecutionResultInput = z.input<typeof addStepExecutionResultInputSchema>;
-export type ClaimStepExecutionsInput = z.input<typeof claimStepExecutionsInputSchema>;
-export type StepExecutionClaimCommandInput = z.input<typeof stepExecutionClaimCommandInputSchema>;
-export type GetStepExecutionWorkerContextInput = z.input<typeof getStepExecutionWorkerContextInputSchema>;
-export type CompleteClaimedStepExecutionInput = z.input<typeof completeClaimedStepExecutionInputSchema>;
-export type GetStepExecutionInput = z.input<typeof getStepExecutionInputSchema>;
-export type GetStepExecutionResultInput = z.input<typeof getStepExecutionResultInputSchema>;
-export type ListStepExecutionsByProjectIdInput = z.input<typeof listStepExecutionsByProjectIdInputSchema>;
-export type StepExecutionWorkerContextContract = z.infer<typeof stepExecutionWorkerContextSchema>;