@hardkas/sdk 0.9.0-alpha → 0.9.1-alpha

package/README.md

@@ -1,51 +1,51 @@
-# `@hardkas/sdk`
-
-The HardKas SDK is the programmatic API for local-first transaction workflows. It exposes the same core model as the CLI: plan, sign, simulate or send, then inspect artifacts and lineage.
-
-## 1. Create A Local SDK
-
-```typescript
-import { Hardkas } from "@hardkas/sdk";
-
-const sdk = await Hardkas.create({
-  cwd: process.cwd(),
-  autoBootstrap: true,
-  network: "simulated"
-});
-```
-
-`autoBootstrap: true` is the easiest local path. It creates or loads the workspace data needed for simulated accounts, artifacts, and local execution.
-
-## 2. Transaction Flow
-
-```typescript
-const plan = await sdk.tx.plan({
-  from: "alice",
-  to: "bob",
-  amount: "1",
-  network: "simulated"
-});
-
-const signed = await sdk.tx.sign(plan, {
-  account: "alice"
-});
-
-const receipt = await sdk.tx.simulate(signed);
-```
-
-For a real RPC-backed node, create the SDK with an explicit network/provider configuration and treat the send step as network-state dependent. Mainnet should remain outside the default local development flow.
-
-## 3. Artifacts And Queries
-
-The SDK can read artifacts, trace lineage, replay local records, and query the local projection:
-
-```typescript
-const artifacts = await sdk.query.artifacts.list();
-const trace = await sdk.lineage.trace(receipt.txId);
-```
-
-The SQLite query store is rebuildable. The durable source of truth is the workspace artifact and event data.
-
-## 4. Boundary
-
-The SDK should be used from Node.js. Browser applications should talk to the dev server through `@hardkas/client`, not import `@hardkas/sdk` directly.
+# `@hardkas/sdk`
+
+The HardKas SDK is the programmatic API for local-first transaction workflows. It exposes the same core model as the CLI: plan, sign, simulate or send, then inspect artifacts and lineage.
+
+## 1. Create A Local SDK
+
+```typescript
+import { Hardkas } from "@hardkas/sdk";
+
+const sdk = await Hardkas.create({
+  cwd: process.cwd(),
+  autoBootstrap: true,
+  network: "simulated"
+});
+```
+
+`autoBootstrap: true` is the easiest local path. It creates or loads the workspace data needed for simulated accounts, artifacts, and local execution.
+
+## 2. Transaction Flow
+
+```typescript
+const plan = await sdk.tx.plan({
+  from: "alice",
+  to: "bob",
+  amount: "1",
+  network: "simulated"
+});
+
+const signed = await sdk.tx.sign(plan, {
+  account: "alice"
+});
+
+const receipt = await sdk.tx.simulate(signed);
+```
+
+For a real RPC-backed node, create the SDK with an explicit network/provider configuration and treat the send step as network-state dependent. Mainnet should remain outside the default local development flow.
+
+## 3. Artifacts And Queries
+
+The SDK can read artifacts, trace lineage, replay local records, and query the local projection:
+
+```typescript
+const artifacts = await sdk.query.artifacts.list();
+const trace = await sdk.lineage.trace(receipt.txId);
+```
+
+The SQLite query store is rebuildable. The durable source of truth is the workspace artifact and event data.
+
+## 4. Boundary
+
+The SDK should be used from Node.js. Browser applications should talk to the dev server through `@hardkas/client`, not import `@hardkas/sdk` directly.

package/dist/index.d.ts

@@ -1,17 +1,65 @@
 import * as _hardkas_config from '@hardkas/config';
 import { LoadedHardkasConfig } from '@hardkas/config';
 export { defineHardkasConfig } from '@hardkas/config';
-import { TxPlanArtifact, SignedTxArtifact, TxReceiptArtifact, HardkasArtifactBase, WorkflowArtifact, ExternalHardkasSigner } from '@hardkas/artifacts';
+import { TxPlanArtifact, SignedTxArtifact, TxReceiptArtifact, HardkasSchemas, HardkasArtifactBase, WorkflowArtifact, ExternalHardkasSigner } from '@hardkas/artifacts';
 export { ARTIFACT_SCHEMAS, HARDKAS_VERSION, SignedTxArtifact, TxPlanArtifact, TxReceiptArtifact, TxTraceArtifact, createTxPlanArtifact, writeArtifact } from '@hardkas/artifacts';
 import { KaspaRpcClient } from '@hardkas/kaspa-rpc';
 import { EventEnvelope, NetworkId } from '@hardkas/core';
-export { ArtifactId, HardkasError, KaspaAddress, LineageId, NetworkId, SOMPI_PER_KAS, TxId, formatSompi, parseKasToSompi } from '@hardkas/core';
+export { ArtifactId, HardkasError, KaspaAddress, LineageId, NetworkId, SOMPI_PER_KAS, TxId, formatSompiToKas, parseKasToSompi } from '@hardkas/core';
 import { HardkasAccount } from '@hardkas/accounts';
 export { signTxPlanArtifact } from '@hardkas/accounts';
 import { L2NetworkProfile } from '@hardkas/l2';
+import { SilverSimulationState } from '@hardkas/simulator';
 export { buildPaymentPlan } from '@hardkas/tx-builder';
 export { ClientEnvelope, HardkasClientOptions, createHardkasClient } from './client.js';
 
+interface HardkasCapabilities {
+    version: string;
+    maturity: "alpha" | "hardened-alpha" | "beta" | "stable";
+    proofVersion: string;
+    hashVersion: number;
+    capabilities: {
+        artifacts: boolean;
+        lineageVerification: boolean;
+        deterministicHashing: boolean;
+        atomicPersistence: boolean;
+        workspaceLocks: boolean;
+        corruptionDetection: boolean;
+        secretRedaction: boolean;
+        mainnetGuards: boolean;
+        localnetSimulation: boolean;
+        ghostdagSimulation: boolean;
+        dagConflictResolution: boolean;
+        massProfiler: boolean;
+        simulationScenarios: boolean;
+        queryStore: boolean;
+        replayVerification: boolean;
+        schemaMigrations: boolean;
+        dockerNode: boolean;
+        scriptRunner: boolean;
+        testingFramework: boolean;
+        l2Profiles: boolean;
+        l2BridgeAssumptions: boolean;
+        consensusValidation: boolean;
+        productionWallet: boolean;
+        silverScript: boolean;
+        covenants: boolean;
+        trustlessExit: boolean;
+        differentialDagValidation: boolean;
+    };
+    trustBoundaries: {
+        replay: "local-workflow-only";
+        artifacts: "internal-integrity-only";
+        simulator: "research-experimental";
+        queryStore: "rebuildable-read-model";
+        l2Bridge: "pre-zk-assumptions";
+    };
+}
+declare class HardkasCapabilitiesApi {
+    get(): Promise<HardkasCapabilities>;
+}
+declare function createHardkasCapabilities(): HardkasCapabilities;
+
 /**
  * HardKAS Accounts Module
  * @alpha
@@ -38,9 +86,9 @@ declare class HardkasAccounts {
         formatted: string;
     }>;
     /**
-     * Lists all configured account names.
+     * Lists all available HardKAS accounts.
      */
-    list(): Promise<string[]>;
+    list(): Promise<Record<string, unknown>[]>;
     /**
      * Funds an account from another account (defaults to 'default' account).
      */
@@ -172,6 +220,48 @@ declare class HardkasQuery {
     }): Promise<readonly EventEnvelope[]>;
 }
 
+interface LocalnetProfileOptions {
+    profile?: "simulated" | "toccata-v2" | string;
+}
+interface LocalnetStatusResult {
+    schema: typeof HardkasSchemas.LocalnetStatusV1;
+    profile: string;
+    node: {
+        ready: boolean;
+        rpcUrl: string;
+        networkId?: string;
+        serverVersion?: string;
+        isSynced?: boolean;
+        virtualDaaScore?: string;
+        lastError?: string;
+    };
+    miner: {
+        exists: boolean;
+        running: boolean;
+        status: string;
+        image: string;
+        name: string;
+    };
+    simulationLevels: {
+        artifactCoherence: "READY";
+        runtimeOutcome: "PARTIAL";
+        vmConsensusEquivalence: "NOT_CLAIMED";
+    };
+}
+interface LocalnetControlResult {
+    schema: typeof HardkasSchemas.LocalnetControlV1;
+    profile: string;
+    status: "SIMULATED_LOCALNET_READY" | "SDK_LOCALNET_CONTROL_UNSUPPORTED";
+    message: string;
+}
+interface LocalnetFundingResult {
+    schema: typeof HardkasSchemas.LocalnetFundingV1;
+    profile: string;
+    identifier: string;
+    status: "SIMULATED_ACCOUNT_FUNDED" | "SDK_TOCCATA_FUNDING_UNSUPPORTED";
+    receipt?: unknown;
+    message: string;
+}
 /**
  * HardKAS Localnet Simulation Module
  */
@@ -183,13 +273,32 @@ declare class HardkasLocalnet {
      */
     isAlive(): Promise<boolean>;
     /**
-     * Future: control localnet process/container from here.
+     * Status check with the same claim boundaries as `hardkas localnet status --json`.
+     */
+    status(options?: LocalnetProfileOptions): Promise<LocalnetStatusResult>;
+    /**
+     * Initializes the in-memory simulated workspace.
+     *
+     * Docker Toccata process control remains a CLI/localnet responsibility in
+     * 0.9.1-alpha; the SDK reports that boundary instead of silently shelling out.
+     */
+    start(options?: LocalnetProfileOptions): Promise<LocalnetControlResult>;
+    /**
+     * Funds a simulated account through the SDK transaction flow.
+     *
+     * Toccata Docker mining/funding remains CLI-only in 0.9.1-alpha because it
+     * depends on a local stratum/miner companion and host Docker state.
      */
-    start(): Promise<void>;
+    fund(identifier: string, options?: LocalnetProfileOptions & {
+        from?: string;
+        amount?: string | bigint;
+    }): Promise<LocalnetFundingResult>;
     /**
      * Resets the localnet state (simulated or node).
      */
     reset(): Promise<void>;
+    private detectToccataNode;
+    private inspectDockerContainer;
 }
 
 interface ReplayVerifyOptions {
@@ -357,6 +466,375 @@ declare class HardkasWorkflow {
     run(options: WorkflowRunOptions): Promise<WorkflowArtifact>;
 }
 
+interface CorpusIssue {
+    code: string;
+    message: string;
+    file?: string;
+}
+interface CorpusVerifyResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ToccataCorpusV1;
+    path: string;
+    summary: {
+        happyPathFixtures: number;
+        failureFixtures: number;
+        artifactsChecked: number;
+        contentHashes: "PASS" | "FAIL";
+        compareMode: string;
+        simulationStatus: string;
+        knownLimitations: string[];
+    };
+    claims: {
+        artifactCoherence: "READY_MATCH" | "INVALID";
+        runtimeOutcome: "PARTIAL" | "INVALID";
+        vmConsensusEquivalence: "NOT_CLAIMED" | "INVALID";
+        mainnet: "BLOCKED_BY_POLICY" | "INVALID";
+    };
+    issues: CorpusIssue[];
+}
+declare class HardkasCorpus {
+    private sdk;
+    constructor(sdk: Hardkas);
+    verify(targetPath: string): Promise<CorpusVerifyResult>;
+}
+declare function verifyToccataCorpus(targetPath: string, workspaceRoot?: string): CorpusVerifyResult;
+
+interface SilverSdkWriteOptions {
+    write?: boolean;
+    outputPath?: string;
+}
+interface SilverCompileOptions extends SilverSdkWriteOptions {
+    file: string;
+    network?: "simnet" | string;
+    compilerPath?: string;
+}
+interface SilverDeployPlanOptions extends SilverSdkWriteOptions {
+    artifact: string | any;
+    from: string;
+    amount?: string | number | bigint;
+    network?: "simnet" | string;
+}
+interface SilverSpendPlanOptions extends SilverSdkWriteOptions {
+    receipt: string | any;
+    args?: Array<{
+        type: "hex";
+        value: string;
+    }>;
+    argsPath?: string;
+    to: string;
+}
+interface SilverCompareOptions {
+    simulated: string | any;
+    docker: string | any;
+    mode?: SilverCompareMode;
+}
+interface SilverSdkArtifactResult<T> {
+    artifact: T;
+    artifactPath?: string;
+}
+type SilverCompareMode = "artifact-coherence" | "runtime-outcome" | "strict";
+interface SilverCompareEntry {
+    field: string;
+    reason: string;
+    classification: "MATCH" | "MISSING_IN_SIM" | "MISSING_IN_REAL" | "SEMANTIC_MISMATCH" | "SEMANTICALLY_DERIVED" | "IGNORED_NON_CONSENSUS";
+}
+interface SilverCompareReport {
+    status: "SILVERSCRIPT_SIMULATION_MATCH" | "SILVERSCRIPT_SIMULATION_DRIFT";
+    mode: SilverCompareMode;
+    drift: SilverCompareEntry[];
+    notes: SilverCompareEntry[];
+    expectedKnownLimitations: ["PARTIAL_VM_SIMULATION"];
+}
+declare class HardkasSilver {
+    private sdk;
+    readonly simulate: {
+        deploy: (deployPlan: string | any, options?: SilverSdkWriteOptions) => Promise<SilverSdkArtifactResult<any>>;
+        spend: (spendPlan: string | any, state?: SilverSimulationState, options?: SilverSdkWriteOptions) => Promise<SilverSdkArtifactResult<any>>;
+        compare: (options: SilverCompareOptions) => Promise<SilverCompareReport>;
+    };
+    constructor(sdk: Hardkas);
+    compile(options: SilverCompileOptions): Promise<SilverSdkArtifactResult<any>>;
+    deployPlan(options: SilverDeployPlanOptions): Promise<SilverSdkArtifactResult<any>>;
+    deploy(options: {
+        artifact: string | any;
+        mode?: "simulate" | "real";
+    } & SilverSdkWriteOptions): Promise<SilverSdkArtifactResult<any>>;
+    spendPlan(options: SilverSpendPlanOptions): Promise<SilverSdkArtifactResult<any>>;
+    spend(options: {
+        artifact: string | any;
+        state?: SilverSimulationState;
+        mode?: "simulate" | "real";
+    } & SilverSdkWriteOptions): Promise<SilverSdkArtifactResult<any>>;
+    simulateDeploy(deployPlan: string | any, options?: SilverSdkWriteOptions): Promise<SilverSdkArtifactResult<any>>;
+    simulateSpend(spendPlan: string | any, state?: SilverSimulationState, options?: SilverSdkWriteOptions): Promise<SilverSdkArtifactResult<any>>;
+    compare(options: SilverCompareOptions): Promise<SilverCompareReport>;
+    private resolveArtifact;
+    private writeSdkArtifact;
+    private simulationStatePath;
+    private loadSimulationState;
+    private saveSimulationState;
+}
+
+type ZkProofSystem = "groth16" | "risc0" | "unknown";
+interface ZkIssue {
+    code: string;
+    message: string;
+    file?: string;
+}
+interface ZkCapabilities {
+    schema: typeof HardkasSchemas.ZkCapabilitiesV1;
+    experimental: true;
+    proofSystems: {
+        groth16: {
+            inspect: true;
+            verifyLocal: "FIXTURE_COHERENCE_ONLY";
+            proofGeneration: "NOT_CLAIMED";
+        };
+        risc0: {
+            inspect: true;
+            verifyLocal: "RISC0_LOCAL_VERIFICATION_NOT_IMPLEMENTED";
+            proofGeneration: "NOT_CLAIMED";
+        };
+    };
+    claims: {
+        zkArtifactCoherence: "EXPERIMENTAL";
+        zkLocalVerification: "EXPERIMENTAL_FIXTURE_ONLY";
+        zkOnchainVerification: "NOT_CLAIMED";
+        vmConsensusEquivalence: "NOT_CLAIMED";
+        mainnet: "BLOCKED_BY_POLICY";
+    };
+    errors: string[];
+}
+interface ZkProofInspectResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ZkProofInspectV1;
+    path: string;
+    proofSystem: ZkProofSystem;
+    status: "ZK_PROOF_INSPECTED" | "ZK_PROOF_INSPECT_FAILED";
+    experimental: true;
+    summary: {
+        files: string[];
+        contentHashes: Record<string, string>;
+        verifierAdapter?: string;
+        expectedStatus?: string;
+    };
+    claims: ZkCapabilities["claims"];
+    issues: ZkIssue[];
+}
+interface ZkProofVerifyResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ZkProofVerificationV1;
+    path: string;
+    proofSystem: ZkProofSystem;
+    status: "ZK_FIXTURE_COHERENCE_PASS" | "ZK_FIXTURE_COHERENCE_FAIL" | "RISC0_LOCAL_VERIFICATION_NOT_IMPLEMENTED" | "ZK_VERIFIER_UNSUPPORTED" | "ZK_VERIFIER_UNAVAILABLE";
+    experimental: true;
+    summary: {
+        verifierAdapter?: string;
+        contentHashes: "PASS" | "FAIL";
+        localVerification: "PASS" | "FAIL" | "NOT_IMPLEMENTED";
+    };
+    claims: ZkCapabilities["claims"];
+    issues: ZkIssue[];
+}
+interface ZkCorpusVerifyResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ZkCorpusVerificationV1;
+    path: string;
+    experimental: true;
+    status: "ZK_CORPUS_VERIFICATION_PASS" | "ZK_CORPUS_VERIFICATION_FAIL";
+    summary: {
+        proofSystems: string[];
+        fixturesChecked: number;
+        artifactsChecked: number;
+        contentHashes: "PASS" | "FAIL";
+        localVerification: "PASS" | "FAIL" | "PARTIAL";
+        knownLimitations: string[];
+    };
+    claims: {
+        zkArtifactCoherence: "READY_MATCH" | "INVALID";
+        zkLocalVerification: "READY_GROTH16_FIXTURE_COHERENCE" | "INVALID";
+        zkOnchainVerification: "NOT_CLAIMED" | "INVALID";
+        runtimeOutcome: "PARTIAL" | "INVALID";
+        vmConsensusEquivalence: "NOT_CLAIMED" | "INVALID";
+        mainnet: "BLOCKED_BY_POLICY" | "INVALID";
+    };
+    issues: ZkIssue[];
+}
+declare class HardkasZk {
+    private sdk;
+    readonly proof: {
+        inspect: (targetPath: string) => Promise<ZkProofInspectResult>;
+        verifyLocal: (targetPath: string) => Promise<ZkProofVerifyResult>;
+    };
+    readonly corpus: {
+        verify: (targetPath: string) => Promise<ZkCorpusVerifyResult>;
+    };
+    constructor(sdk: Hardkas);
+    capabilities(): Promise<ZkCapabilities>;
+}
+declare function createZkCapabilities(): ZkCapabilities;
+declare function inspectZkProof(targetPath: string, workspaceRoot?: string): Promise<ZkProofInspectResult>;
+declare function verifyZkProofLocal(targetPath: string, workspaceRoot?: string): Promise<ZkProofVerifyResult>;
+declare function verifyZkCorpus(targetPath: string, workspaceRoot?: string): Promise<ZkCorpusVerifyResult>;
+
+interface VprogsClaims {
+    vProgsArtifactInspection: "READY";
+    vProgsRuntime: "NOT_CLAIMED";
+    vProgsStableApi: "NOT_CLAIMED";
+    zkOnchainVerification: "NOT_CLAIMED";
+    vmConsensusEquivalence: "NOT_CLAIMED";
+    mainnet: "BLOCKED_BY_POLICY";
+}
+interface VprogsCapabilitiesResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.VProgsCapabilitiesV1;
+    status: "VPROGS_INSPECT_SURFACE_READY";
+    claims: VprogsClaims;
+    errors: string[];
+}
+interface VprogsStatusResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.VProgsStatusV1;
+    status: "VPROGS_INSPECT_SURFACE_READY";
+    claims: VprogsClaims;
+}
+interface VprogsInspectResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.VProgsInspectV1;
+    status: "VPROGS_ARTIFACT_INSPECTED" | "VPROGS_ARTIFACT_INVALID";
+    path: string;
+    artifactHash?: string;
+    artifactSchema?: string;
+    claims: VprogsClaims;
+    issues: Array<{
+        code: string;
+        message: string;
+        file?: string;
+    }>;
+}
+declare class HardkasVprogs {
+    private sdk;
+    constructor(sdk: Hardkas);
+    capabilities(): Promise<VprogsCapabilitiesResult>;
+    status(): Promise<VprogsStatusResult>;
+    inspect(targetPath: string): Promise<VprogsInspectResult>;
+}
+declare function createVprogsCapabilities(): VprogsCapabilitiesResult;
+declare function createVprogsStatus(): VprogsStatusResult;
+declare function inspectVprogsArtifact(targetPath: string, workspaceRoot?: string): Promise<VprogsInspectResult>;
+
+type ProgrammabilityKind = "silver" | "zk" | "vprog" | "full-lab";
+interface ProgrammabilityClaims {
+    artifactCoherence: "READY_MATCH";
+    silverScriptBuilder: "SILVERSCRIPT_BUILDER_READY";
+    zkCorpusSurface: "ZK_CORPUS_SURFACE_READY";
+    zkLocalVerification: "READY_GROTH16_FIXTURE_COHERENCE";
+    risc0InspectSurface: "RISC0_INSPECT_SURFACE_READY";
+    vProgsInspectSurface: "VPROGS_INSPECT_SURFACE_READY";
+    runtimeOutcome: "PARTIAL";
+    vmConsensusEquivalence: "NOT_CLAIMED";
+    zkOnchainVerification: "NOT_CLAIMED";
+    vProgsRuntime: "NOT_CLAIMED";
+    vProgsStableApi: "NOT_CLAIMED";
+    mainnet: "BLOCKED_BY_POLICY";
+}
+interface ProgrammabilityIssue {
+    code: string;
+    message: string;
+    file?: string;
+}
+interface ProgrammabilityCapabilitiesResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ProgrammabilityCapabilitiesV1;
+    status: "PROGRAMMABILITY_SURFACE_READY";
+    surfaces: {
+        silverScript: "SILVERSCRIPT_BUILDER_READY";
+        zkCorpus: "ZK_CORPUS_SURFACE_READY";
+        groth16FixtureCoherence: "READY_GROTH16_FIXTURE_COHERENCE";
+        risc0Inspect: "RISC0_INSPECT_SURFACE_READY";
+        vProgsInspect: "VPROGS_INSPECT_SURFACE_READY";
+    };
+    claims: ProgrammabilityClaims;
+    nonClaims: string[];
+}
+interface ProgrammabilityInspectResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ProgrammabilityInspectV1;
+    status: "PROGRAMMABILITY_ARTIFACT_INSPECTED" | "PROGRAMMABILITY_ARTIFACT_INVALID";
+    kind: Exclude<ProgrammabilityKind, "full-lab">;
+    path: string;
+    artifactSchema?: string;
+    contentHash?: string;
+    sourceStatus?: string;
+    claims: ProgrammabilityClaims;
+    issues: ProgrammabilityIssue[];
+}
+interface ProgrammabilityVerifyResult {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ProgrammabilityVerifyV1;
+    status: "PROGRAMMABILITY_VERIFY_PASS" | "PROGRAMMABILITY_VERIFY_FAIL" | "PROGRAMMABILITY_VERIFY_PARTIAL";
+    kind: Exclude<ProgrammabilityKind, "full-lab">;
+    path: string;
+    sourceStatus?: string;
+    claims: ProgrammabilityClaims;
+    issues: ProgrammabilityIssue[];
+}
+interface ProgrammabilityCorpusReport {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ProgrammabilityCorpusReportV1;
+    path: string;
+    status: "PROGRAMMABILITY_CORPUS_PASS" | "PROGRAMMABILITY_CORPUS_FAIL";
+    summary: {
+        silver: "PASS" | "FAIL" | "SKIPPED";
+        zk: "PASS" | "FAIL" | "SKIPPED";
+        vprogs: "PASS" | "FAIL" | "SKIPPED";
+        rootManifest: "PASS" | "FAIL";
+        knownLimitations: string[];
+    };
+    claims: ProgrammabilityClaims;
+    issues: ProgrammabilityIssue[];
+}
+interface ProgrammabilityAppPlan {
+    ok: boolean;
+    schema: typeof HardkasSchemas.ProgrammabilityAppPlanV1;
+    status: "PROGRAMMABILITY_APP_PLAN_READY";
+    kind: ProgrammabilityKind;
+    template: string;
+    commands: string[];
+    sdkSurfaces: string[];
+    claims: ProgrammabilityClaims;
+    nonClaims: string[];
+}
+declare class HardkasProgrammability {
+    private sdk;
+    readonly corpus: {
+        verify: (options?: {
+            path?: string;
+            include?: Array<"silver" | "zk" | "vprogs">;
+        }) => Promise<ProgrammabilityCorpusReport>;
+    };
+    readonly app: {
+        plan: (options?: {
+            kind?: ProgrammabilityKind;
+            template?: string;
+        }) => ProgrammabilityAppPlan;
+    };
+    constructor(sdk: Hardkas);
+    capabilities(): Promise<ProgrammabilityCapabilitiesResult>;
+    inspect(options: {
+        kind: Exclude<ProgrammabilityKind, "full-lab">;
+        path: string;
+    }): Promise<ProgrammabilityInspectResult>;
+    verify(options: {
+        kind: Exclude<ProgrammabilityKind, "full-lab">;
+        path: string;
+    }): Promise<ProgrammabilityVerifyResult>;
+    private verifyCorpus;
+    private planApp;
+}
+declare function createProgrammabilityCapabilities(): ProgrammabilityCapabilitiesResult;
+declare function programmabilityClaims(): ProgrammabilityClaims;
+
 interface TaskArgs {
     [key: string]: string | boolean | undefined;
 }
@@ -413,6 +891,12 @@ declare class Hardkas {
     readonly replay: HardkasReplay;
     readonly lineage: HardkasLineage;
     readonly workflow: HardkasWorkflow;
+    readonly capabilitiesApi: HardkasCapabilitiesApi;
+    readonly corpus: HardkasCorpus;
+    readonly silver: HardkasSilver;
+    readonly zk: HardkasZk;
+    readonly vprogs: HardkasVprogs;
+    readonly programmability: HardkasProgrammability;
     readonly signer?: ExternalHardkasSigner | undefined;
     readonly mode: "developer" | "agent";
     readonly policy: Required<NonNullable<HardkasOptions["policy"]>>;
@@ -433,6 +917,7 @@ declare class Hardkas {
     get network(): NetworkId;
     get sdkConfig(): _hardkas_config.HardkasConfig;
     get cwd(): string;
+    capabilities(): Promise<HardkasCapabilities>;
     /**
      * Validates an action against the active security policy.
      * Throws HardkasError if the policy is violated.
@@ -440,4 +925,4 @@ declare class Hardkas {
     enforcePolicy(action: "network" | "mainnet" | "external-wallet" | "mutation", context?: string): void;
 }
 
-export { Hardkas, HardkasAccounts, HardkasArtifactsManager, HardkasL2, HardkasLineage, HardkasLocalnet, type HardkasOptions, HardkasQuery, HardkasReplay, HardkasTx, HardkasWorkspace, type TaskArgs, type TaskContext, defineTask };
+export { type CorpusIssue, type CorpusVerifyResult, Hardkas, HardkasAccounts, HardkasArtifactsManager, type HardkasCapabilities, HardkasCapabilitiesApi, HardkasCorpus, HardkasL2, HardkasLineage, HardkasLocalnet, type HardkasOptions, HardkasProgrammability, HardkasQuery, HardkasReplay, HardkasSilver, HardkasTx, HardkasVprogs, HardkasWorkspace, HardkasZk, type ProgrammabilityAppPlan, type ProgrammabilityCapabilitiesResult, type ProgrammabilityClaims, type ProgrammabilityCorpusReport, type ProgrammabilityInspectResult, type ProgrammabilityKind, type ProgrammabilityVerifyResult, type SilverCompareMode, type SilverCompareOptions, type SilverCompareReport, type SilverCompileOptions, type SilverDeployPlanOptions, type SilverSdkArtifactResult, type SilverSdkWriteOptions, type SilverSpendPlanOptions, type TaskArgs, type TaskContext, type VprogsCapabilitiesResult, type VprogsClaims, type VprogsInspectResult, type VprogsStatusResult, type ZkCapabilities, type ZkCorpusVerifyResult, type ZkIssue, type ZkProofInspectResult, type ZkProofSystem, type ZkProofVerifyResult, createHardkasCapabilities, createProgrammabilityCapabilities, createVprogsCapabilities, createVprogsStatus, createZkCapabilities, defineTask, inspectVprogsArtifact, inspectZkProof, programmabilityClaims, verifyToccataCorpus, verifyZkCorpus, verifyZkProofLocal };