humanish 0.0.1 → 0.15.0

package/dist/concurrency.js

@@ -0,0 +1,27 @@
+// Bounded-concurrency map: run `mapper` over `items` with at most `concurrency` in flight at a
+// time, preserving input order in the result array. Hoisted out of run.ts so every fan-out
+// caller (run.ts's local-actor lanes AND cua-actor-lab.ts's multi-lane desktops) shares ONE
+// implementation — three call sites across modules. Behaviour is identical to run.ts's original
+// private copy: a worker pool of size min(concurrency, items.length) pulls the next index until
+// the list is drained, and `results[i]` always corresponds to `items[i]`.
+export async function mapWithConcurrency(items, concurrency, mapper) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(concurrency, items.length);
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= items.length) {
+                return;
+            }
+            const item = items[index];
+            if (item === undefined) {
+                return;
+            }
+            results[index] = await mapper(item, index);
+        }
+    }));
+    return results;
+}
+//# sourceMappingURL=concurrency.js.map

package/dist/concurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.js","sourceRoot":"","sources":["../src/concurrency.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,2FAA2F;AAC3F,4FAA4F;AAC5F,gGAAgG;AAChG,gGAAgG;AAChG,0EAA0E;AAE1E,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,KAAU,EACV,WAAmB,EACnB,MAA8C;IAE9C,MAAM,OAAO,GAAQ,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAExD,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,KAAK,IAAI,EAAE;QAC/D,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,KAAK,GAAG,SAAS,CAAC;YACxB,SAAS,IAAI,CAAC,CAAC;YACf,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;gBAC1B,OAAO;YACT,CAAC;YAED,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,OAAO;YACT,CAAC;YACD,OAAO,CAAC,KAAK,CAAC,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC,CAAC,CAAC,CAAC;IAEJ,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/concurrent-shared-world-lab.d.ts

@@ -0,0 +1,115 @@
+import { type CuaActorDescriptor } from "./actor-registry.js";
+import { type CuaLaneSpec, type LaneRunOutcome } from "./cua-actor-lab.js";
+import { type LabActorLane, type LabConfig } from "./lab-config.js";
+import { type ObserverResult } from "./observer.js";
+import { type SharedWorldLabHooks } from "./shared-world-lab.js";
+import { type RunBundle, type RunSubjectProvenance, type SharedWorldStateSnapshot } from "./run.js";
+export declare const CONCURRENT_SHARED_WORLD_LAB_SCHEMA = "humanish.concurrent-shared-world-lab-result.v1";
+export declare const CONCURRENT_SHARED_WORLD_PROVIDER_METADATA: {
+    readonly mode: "concurrent-shared-world-lab";
+    readonly tool: "humanish";
+};
+export declare const CONCURRENT_ATTRIBUTION_LIMITS: readonly ["concurrent", "best-effort-causal-attribution", "non-deterministic-shared-state", "window-and-snapshot-granularity", "contention-observed-not-proven-safe", "state-change-not-isolated-to-actors"];
+export interface RunConcurrentSharedWorldLabOptions {
+    cwd: string;
+    config: LabConfig;
+    /** Resolved upstream (scenario.mode + CLI override); defaults safe (dry-run). */
+    dryRun: boolean;
+    open?: boolean;
+    runId?: string;
+    onObserverReady?: (observer: ObserverResult & {
+        ok: true;
+    }) => Promise<void> | void;
+    hooks?: SharedWorldLabHooks;
+}
+export type ConcurrentSharedWorldLabErrorCode = "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_ACTOR_UNSUPPORTED" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_INVALID" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_KEYS_MISSING" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_SUBJECT_ENV_MISSING" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_GETHOST_UNAVAILABLE";
+/** One persona's OUTCOME against the contended world (the "M of N" headline). */
+export interface ConcurrentSharedWorldRoleResult {
+    id: string;
+    index: number;
+    persona: string;
+    status: string;
+    ok: boolean;
+    /** The harness-clocked [start,end] window the orchestrator measured (live). */
+    window?: {
+        startedAt: number;
+        endedAt: number;
+    };
+    session?: {
+        status: string;
+        completionReason: string;
+        reason: string;
+        screenshots: number;
+    };
+    /** The actor sandbox lifecycle proof (the getHost/key value is never surfaced here). */
+    sandbox?: {
+        sandboxId: string;
+        killed: boolean;
+    };
+    error?: {
+        code: ConcurrentSharedWorldLabErrorCode;
+        message: string;
+    };
+}
+export interface ConcurrentSharedWorldLabResult {
+    schema: typeof CONCURRENT_SHARED_WORLD_LAB_SCHEMA;
+    ok: boolean;
+    cwd: string;
+    labId: string;
+    actor: string;
+    topology: "shared-world";
+    topologyMode: "concurrent";
+    /** The DECLARED number of persona seats. */
+    roleCount: number;
+    /** Effective in-flight bound (execution.concurrency). */
+    concurrency: number;
+    dryRun: boolean;
+    runId: string;
+    /** The harness-minted getHost URL the actors drove (tokenless; live only). */
+    host?: string;
+    /** The ONE subject sandbox lifecycle proof. */
+    subjectSandbox?: {
+        sandboxId: string;
+        killed: boolean;
+    };
+    /** Whether ≥2 actor windows overlapped in time (proven concurrency; live only). */
+    overlapProven?: boolean;
+    /** Subject provenance (invariant 5): the ONE shared plane. */
+    subject?: RunSubjectProvenance;
+    roles: ConcurrentSharedWorldRoleResult[];
+    observer?: ObserverResult;
+    warnings: string[];
+    error?: {
+        code: ConcurrentSharedWorldLabErrorCode;
+        message: string;
+    };
+}
+/** One actor lane's measured run (internal). */
+interface ActorLaneResult {
+    spec: CuaLaneSpec;
+    outcome: LaneRunOutcome;
+    startedAt: number;
+    endedAt: number;
+    route: string;
+}
+export declare function runConcurrentSharedWorld(options: RunConcurrentSharedWorldLabOptions): Promise<ConcurrentSharedWorldLabResult>;
+/** Project the concurrent run into a humanish.run-bundle.v1 with the CONCURRENT shared-world block. */
+export declare function buildConcurrentSharedWorldBundle(args: {
+    config: LabConfig;
+    descriptor: CuaActorDescriptor;
+    createdAt: string;
+    dryRun: boolean;
+    inProgress?: boolean;
+    runId: string;
+    source: RunBundle["source"];
+    roles: LabActorLane[];
+    actorSpecs: CuaLaneSpec[];
+    actorResults: ActorLaneResult[];
+    stateSnapshots: SharedWorldStateSnapshot[];
+    subject: RunSubjectProvenance;
+    seedDigest: string;
+    subjectCommit?: string;
+    hostDigest?: string;
+    runError?: string;
+}): RunBundle;
+export {};