rhachet 1.1.0

package/dist/__test_assets__/threads/codeCritic.d.ts

@@ -0,0 +1,6 @@
+import { Thread } from '../../domain/objects/Thread';
+import { ThreadContextRole } from '../../domain/objects/Threads';
+export declare const getExampleThreadCodeCritic: () => Promise<Thread<ThreadContextRole<'critic'> & {
+    tools: string[];
+    facts: string[];
+}>>;

package/dist/__test_assets__/threads/codeCritic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExampleThreadCodeCritic = void 0;
+const getFile_1 = require("../../__nonpublished_modules__/file-fns/src/getFile");
+const Thread_1 = require("../../domain/objects/Thread");
+const directory_1 = require("../directory");
+// todo: use enroleThread to add role context & apply role tools
+const getExampleThreadCodeCritic = async () => new Thread_1.Thread({
+    context: {
+        role: 'critic',
+        tools: [],
+        facts: [
+            await (0, getFile_1.getFile)({
+                path: directory_1.directoryTestAssets + '/context/facts/codeEnvTypescript.scene.md',
+            }),
+        ],
+    },
+    stitches: [], // no history yet, by default
+});
+exports.getExampleThreadCodeCritic = getExampleThreadCodeCritic;
+//# sourceMappingURL=codeCritic.js.map

package/dist/__test_assets__/threads/codeCritic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeCritic.js","sourceRoot":"","sources":["../../../src/__test_assets__/threads/codeCritic.ts"],"names":[],"mappings":";;;AAAA,iFAA8E;AAC9E,wDAAqD;AAErD,4CAAmD;AAEnD,gEAAgE;AACzD,MAAM,0BAA0B,GAAG,KAAK,IAE7C,EAAE,CACF,IAAI,eAAM,CAER;IACA,OAAO,EAAE;QACP,IAAI,EAAE,QAAiB;QACvB,KAAK,EAAE,EAAE;QACT,KAAK,EAAE;YACL,MAAM,IAAA,iBAAO,EAAC;gBACZ,IAAI,EACF,+BAAmB,GAAG,2CAA2C;aACpE,CAAC;SACH;KACF;IACD,QAAQ,EAAE,EAAE,EAAE,6BAA6B;CAC5C,CAAC,CAAC;AAjBQ,QAAA,0BAA0B,8BAiBlC"}

package/dist/__test_assets__/threads/director.d.ts

@@ -0,0 +1,6 @@
+import { Thread } from '../../domain/objects/Thread';
+import { ThreadContextRole } from '../../domain/objects/Threads';
+export declare const exampleThreadDirector: import("domain-objects/dist/manipulation/immute/withImmute").WithImmute<Thread<ThreadContextRole<"director"> & {
+    tools: string[];
+    facts: string[];
+}>>;

package/dist/__test_assets__/threads/director.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exampleThreadDirector = void 0;
+const Thread_1 = require("../../domain/objects/Thread");
+// todo: use enroleThread to add role context & apply role tools
+exports.exampleThreadDirector = Thread_1.Thread.build({
+    context: {
+        role: 'director',
+        tools: [],
+        facts: [],
+    },
+    stitches: [], // no history yet, by default
+});
+//# sourceMappingURL=director.js.map

package/dist/__test_assets__/threads/director.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"director.js","sourceRoot":"","sources":["../../../src/__test_assets__/threads/director.ts"],"names":[],"mappings":";;;AAAA,wDAAqD;AAGrD,gEAAgE;AACnD,QAAA,qBAAqB,GAAG,eAAM,CAAC,KAAK,CAE/C;IACA,OAAO,EAAE;QACP,IAAI,EAAE,UAAmB;QACzB,KAAK,EAAE,EAAE;QACT,KAAK,EAAE,EAAE;KACV;IACD,QAAQ,EAAE,EAAE,EAAE,6BAA6B;CAC5C,CAAC,CAAC"}

package/dist/contract/sdk.d.ts

@@ -0,0 +1,8 @@
+export { genStitchChoice } from '../logic/weave/compose/genStitchChoice';
+export { genStitchCycle } from '../logic/weave/compose/genStitchCycle';
+export { genStitchFanout } from '../logic/weave/compose/genStitchFanout';
+export { genStitchRoute } from '../logic/weave/compose/genStitchRoute';
+export { enweaveOneStitcher } from '../logic/weave/enweaveOneStitcher';
+export { asStitcher } from '../logic/weave/compose/asStitcher';
+export { asStitcherFlat } from '../logic/weave/compose/asStitcherFlat';
+export * from '../domain/objects';

package/dist/contract/sdk.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asStitcherFlat = exports.asStitcher = exports.enweaveOneStitcher = exports.genStitchRoute = exports.genStitchFanout = exports.genStitchCycle = exports.genStitchChoice = void 0;
+var genStitchChoice_1 = require("../logic/weave/compose/genStitchChoice");
+Object.defineProperty(exports, "genStitchChoice", { enumerable: true, get: function () { return genStitchChoice_1.genStitchChoice; } });
+var genStitchCycle_1 = require("../logic/weave/compose/genStitchCycle");
+Object.defineProperty(exports, "genStitchCycle", { enumerable: true, get: function () { return genStitchCycle_1.genStitchCycle; } });
+var genStitchFanout_1 = require("../logic/weave/compose/genStitchFanout");
+Object.defineProperty(exports, "genStitchFanout", { enumerable: true, get: function () { return genStitchFanout_1.genStitchFanout; } });
+var genStitchRoute_1 = require("../logic/weave/compose/genStitchRoute");
+Object.defineProperty(exports, "genStitchRoute", { enumerable: true, get: function () { return genStitchRoute_1.genStitchRoute; } });
+var enweaveOneStitcher_1 = require("../logic/weave/enweaveOneStitcher");
+Object.defineProperty(exports, "enweaveOneStitcher", { enumerable: true, get: function () { return enweaveOneStitcher_1.enweaveOneStitcher; } });
+var asStitcher_1 = require("../logic/weave/compose/asStitcher");
+Object.defineProperty(exports, "asStitcher", { enumerable: true, get: function () { return asStitcher_1.asStitcher; } });
+var asStitcherFlat_1 = require("../logic/weave/compose/asStitcherFlat");
+Object.defineProperty(exports, "asStitcherFlat", { enumerable: true, get: function () { return asStitcherFlat_1.asStitcherFlat; } });
+__exportStar(require("../domain/objects"), exports);
+//# sourceMappingURL=sdk.js.map

package/dist/contract/sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.js","sourceRoot":"","sources":["../../src/contract/sdk.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,0EAAyE;AAAhE,kHAAA,eAAe,OAAA;AACxB,wEAAuE;AAA9D,gHAAA,cAAc,OAAA;AACvB,0EAAyE;AAAhE,kHAAA,eAAe,OAAA;AACxB,wEAAuE;AAA9D,gHAAA,cAAc,OAAA;AAEvB,wEAAuE;AAA9D,wHAAA,kBAAkB,OAAA;AAE3B,gEAA+D;AAAtD,wGAAA,UAAU,OAAA;AACnB,wEAAuE;AAA9D,gHAAA,cAAc,OAAA;AAEvB,oDAAkC"}

package/dist/domain/objects/Stitch.d.ts

@@ -0,0 +1,42 @@
+import { UniDateTime } from '@ehmpathy/uni-time';
+import { DomainEntity } from 'domain-objects';
+import { Uuid } from 'uuid-fns';
+import { StitchTrail, StitchTrailDesc } from './StitchTrail';
+import { StitcherDesc } from './Stitcher';
+export interface Stitch<TOutput> {
+    /**
+     * .what = a unique identifier for the stitch
+     */
+    uuid: Uuid;
+    /**
+     * .what = when the stitch was set
+     */
+    createdAt: UniDateTime;
+    /**
+     * .what = the stitcher that set it
+     * .note =
+     *   - may be null if it was a manually created stitch
+     */
+    stitcher: StitcherDesc<any> | null;
+    /**
+     * .what = the trail from which the stitch came
+     * .note =
+     *   - the markers may not always be present today // todo: hide them on output, instead of on input, longterm
+     *   - the trail itself may not be declared, e.g., if it was a manually created stitch
+     */
+    trail: {
+        desc: StitchTrailDesc;
+        markers?: StitchTrail;
+    } | null;
+    /**
+     * .what = the prompt input which caused the output
+     */
+    input: any;
+    /**
+     * .what = the output of the stitch
+     */
+    output: TOutput;
+}
+export declare class Stitch<TOutput> extends DomainEntity<Stitch<TOutput>> implements Stitch<TOutput> {
+    static primary: readonly ["uuid"];
+}

package/dist/domain/objects/Stitch.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stitch = void 0;
+const domain_objects_1 = require("domain-objects");
+class Stitch extends domain_objects_1.DomainEntity {
+}
+exports.Stitch = Stitch;
+Stitch.primary = ['uuid'];
+//# sourceMappingURL=Stitch.js.map

package/dist/domain/objects/Stitch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stitch.js","sourceRoot":"","sources":["../../../src/domain/objects/Stitch.ts"],"names":[],"mappings":";;;AACA,mDAA6D;AA6C7D,MAAa,MACX,SAAQ,6BAA6B;;AADvC,wBAKC;AADe,cAAO,GAAG,CAAC,MAAM,CAAU,CAAC"}

package/dist/domain/objects/StitchChoice.d.ts

@@ -0,0 +1,30 @@
+import { DomainLiteral } from 'domain-objects';
+import { GStitcher, Stitcher, StitcherBase, StitcherForm } from './Stitcher';
+import { Threads } from './Threads';
+/**
+ * .what = fork+choose composite stitcher
+ * .how =
+ *   - declare the stitcher options to choose from
+ *   - declare a stitcher to choose one
+ * .note =
+ *   - choose multiple can be composed via choice of a fanout route
+ */
+export interface StitchChoice<TStitcher extends GStitcher<Threads<any, 'single'>, any, any>> extends StitcherBase<StitcherForm.CHOICE> {
+    /**
+     * .what = the stitcher which decides the choice
+     */
+    decider: Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], {
+        choice: {
+            slug: string;
+        };
+    }>>;
+    /**
+     * .what = the set of stitchers to choose one from
+     */
+    options: [
+        Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], any>>,
+        ...Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], any>>[]
+    ];
+}
+export declare class StitchChoice<TStitcher extends GStitcher<Threads<any, 'single'>, any, any>> extends DomainLiteral<StitchChoice<TStitcher>> implements StitchChoice<TStitcher> {
+}

package/dist/domain/objects/StitchChoice.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StitchChoice = void 0;
+const domain_objects_1 = require("domain-objects");
+class StitchChoice extends domain_objects_1.DomainLiteral {
+}
+exports.StitchChoice = StitchChoice;
+//# sourceMappingURL=StitchChoice.js.map

package/dist/domain/objects/StitchChoice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StitchChoice.js","sourceRoot":"","sources":["../../../src/domain/objects/StitchChoice.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AAmC/C,MAAa,YAGX,SAAQ,8BAAsC;CACT;AAJvC,oCAIuC"}

package/dist/domain/objects/StitchCycle.d.ts

@@ -0,0 +1,44 @@
+import { UniDuration } from '@ehmpathy/uni-time';
+import { DomainLiteral } from 'domain-objects';
+import { PickAny } from 'type-fns';
+import { GStitcher, Stitcher, StitcherBase, StitcherForm } from './Stitcher';
+import { Threads } from './Threads';
+/**
+ * .what = repeater composite stitcher
+ * .how =
+ *   - declare the repeatee, which will be repeated while decider chooses 'repeat'
+ *   - declare the decider, which selects 'repeat', 'release', or 'halt'
+ * .note =
+ *   - by default, will halt if 100cycles or 1hrs have been reached
+ *   - fails fast; you can always resume a weave from the event stream after fix of error
+ */
+export interface StitchCycle<TStitcher extends GStitcher<Threads<any, 'single'>, any, any>> extends StitcherBase<StitcherForm.CYCLE> {
+    /**
+     * .what = the stitcher to repeat
+     */
+    repeatee: Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], any>>;
+    /**
+     * .what = the stitcher which decides whether to repeat, release, or halt
+     * .output = { choice: 'repeat' | 'release' | 'halt' }
+     */
+    decider: Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], {
+        choice: 'repeat' | 'release' | 'halt';
+    }>>;
+    /**
+     * .what = the configuration of when to halt the cycler, to prevent infiloop
+     */
+    halter: {
+        threshold: PickAny<{
+            /**
+             * the number of repetitions of the cycle
+             */
+            repetitions: number;
+            /**
+             * the amount of time spent in the cycle
+             */
+            duration: UniDuration;
+        }>;
+    };
+}
+export declare class StitchCycle<TStitcher extends GStitcher<Threads<any, 'single'>, any, any>> extends DomainLiteral<StitchCycle<TStitcher>> implements StitchCycle<TStitcher> {
+}

package/dist/domain/objects/StitchCycle.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StitchCycle = void 0;
+const domain_objects_1 = require("domain-objects");
+class StitchCycle extends domain_objects_1.DomainLiteral {
+}
+exports.StitchCycle = StitchCycle;
+//# sourceMappingURL=StitchCycle.js.map

package/dist/domain/objects/StitchCycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StitchCycle.js","sourceRoot":"","sources":["../../../src/domain/objects/StitchCycle.ts"],"names":[],"mappings":";;;AACA,mDAA+C;AAuD/C,MAAa,WAGX,SAAQ,8BAAqC;CACT;AAJtC,kCAIsC"}

package/dist/domain/objects/StitchFanout.d.ts

@@ -0,0 +1,35 @@
+import { DomainLiteral } from 'domain-objects';
+import { StitchStep } from './StitchStep';
+import { GStitcher, Stitcher, StitcherBase, StitcherForm } from './Stitcher';
+import { Thread } from './Thread';
+import { Threads } from './Threads';
+/**
+ * .what = parallel composite stitcher
+ * .how =
+ *   - fanout pattern to run substitchers in parallel
+ *   - fanin to merge via a conclusion
+ * .note = a StitchFanout is a composite Stitcher, similar to StitchRoute, but runs multiple branches in parallel
+ */
+export interface StitchFanout<TStitcher extends GStitcher<Threads<any, 'single'>, any, any>> extends StitcherBase<StitcherForm.FANOUT> {
+    /**
+     * .what = the set of stitchers to run in parallel
+     */
+    parallels: [
+        Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], any>>,
+        ...Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], any>>[]
+    ];
+    /**
+     * .what = a final stitcher that merges the parallel outputs
+     * .why = synthesizes the results into one final output
+     * .note = input threads contain arrays per role, due to parallel fanout
+     */
+    concluder: StitchStep<GStitcher<ThreadsFromFanout<TStitcher>, TStitcher['context'], TStitcher['output']>>;
+}
+export declare class StitchFanout<TStitcher extends GStitcher<Threads<any, 'single'>, any, any>> extends DomainLiteral<StitchFanout<TStitcher>> implements StitchFanout<TStitcher> {
+}
+/**
+ * .what = transforms threads to an array-of-each-thread for fanouts
+ */
+export type ThreadsFromFanout<T extends GStitcher<Threads<any, 'single'>, any, any>> = Threads<{
+    [K in keyof T['threads'] & string]: T['threads'][K] extends Thread<infer C> ? C extends object ? C : never : never;
+}, 'multiple'>;

package/dist/domain/objects/StitchFanout.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StitchFanout = void 0;
+const domain_objects_1 = require("domain-objects");
+class StitchFanout extends domain_objects_1.DomainLiteral {
+}
+exports.StitchFanout = StitchFanout;
+//# sourceMappingURL=StitchFanout.js.map

package/dist/domain/objects/StitchFanout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StitchFanout.js","sourceRoot":"","sources":["../../../src/domain/objects/StitchFanout.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AAsC/C,MAAa,YAGX,SAAQ,8BAAsC;CACT;AAJvC,oCAIuC"}

package/dist/domain/objects/StitchRoute.d.ts

@@ -0,0 +1,22 @@
+import { DomainLiteral } from 'domain-objects';
+import { GStitcher, Stitcher, StitcherBase, StitcherForm } from './Stitcher';
+/**
+ * .what = a route of stitchers to enstich in sequence; a composed tactic
+ * .note = a StitchRoute is really just a composite Stitcher
+ *   - e.g., see the generic parameter input
+ */
+export interface StitchRoute<
+/**
+ * .note = a StitchRoute is really just a composite Stitcher
+ */
+TStitcher extends GStitcher> extends StitcherBase<StitcherForm.ROUTE> {
+    /**
+     * .what = the route of stitchers to execute in sequence
+     */
+    sequence: [
+        ...Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], any>>[],
+        Stitcher<GStitcher<TStitcher['threads'], TStitcher['context'], TStitcher['output']>>
+    ];
+}
+export declare class StitchRoute<TStitcher extends GStitcher> extends DomainLiteral<StitchRoute<TStitcher>> implements StitchRoute<TStitcher> {
+}

package/dist/domain/objects/StitchRoute.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StitchRoute = void 0;
+const domain_objects_1 = require("domain-objects");
+class StitchRoute extends domain_objects_1.DomainLiteral {
+}
+exports.StitchRoute = StitchRoute;
+//# sourceMappingURL=StitchRoute.js.map

package/dist/domain/objects/StitchRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StitchRoute.js","sourceRoot":"","sources":["../../../src/domain/objects/StitchRoute.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AAoC/C,MAAa,WACX,SAAQ,8BAAqC;CACT;AAFtC,kCAEsC"}

package/dist/domain/objects/StitchSetEvent.d.ts

@@ -0,0 +1,23 @@
+import { UniDateTime } from '@ehmpathy/uni-time';
+import { DomainLiteral } from 'domain-objects';
+import { Stitch } from './Stitch';
+import { Threads } from './Threads';
+/**
+ * .what = an event that describes the occurrence of a stich being set
+ */
+export interface StitchSetEvent<TThreads extends Threads<any, 'single'>, TOutput> {
+    /**
+     * .what = when the stitch was set
+     */
+    occurredAt: UniDateTime;
+    /**
+     * .what = the stitch which was set
+     */
+    stitch: Stitch<TOutput>;
+    /**
+     * .what = the threads it was set with
+     */
+    threads: TThreads;
+}
+export declare class StitchSetEvent<TThreads extends Threads<any, 'single'>, TOutput> extends DomainLiteral<StitchSetEvent<TThreads, TOutput>> implements StitchSetEvent<TThreads, TOutput> {
+}

package/dist/domain/objects/StitchSetEvent.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StitchSetEvent = void 0;
+const domain_objects_1 = require("domain-objects");
+class StitchSetEvent extends domain_objects_1.DomainLiteral {
+}
+exports.StitchSetEvent = StitchSetEvent;
+//# sourceMappingURL=StitchSetEvent.js.map

package/dist/domain/objects/StitchSetEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StitchSetEvent.js","sourceRoot":"","sources":["../../../src/domain/objects/StitchSetEvent.ts"],"names":[],"mappings":";;;AACA,mDAA+C;AA2B/C,MAAa,cACX,SAAQ,8BAAgD;CACT;AAFjD,wCAEiD"}

package/dist/domain/objects/StitchStep.d.ts

@@ -0,0 +1,55 @@
+import { DomainLiteral } from 'domain-objects';
+import { Stitch } from './Stitch';
+import { GStitcher, StitcherBase, StitcherForm } from './Stitcher';
+import { Threads } from './Threads';
+/**
+ * .what = a step by which to stitch, via computation
+ */
+export interface StitchStepCompute<TStitcher extends GStitcher<Threads<any, any>, any, any>> extends StitcherBase<StitcherForm.COMPUTE> {
+    /**
+     * .what = the procedure which will compute the stitch upon invocation
+     */
+    invoke: (input: {
+        threads: TStitcher['threads'];
+    }, context: TStitcher['context']) => Promise<Pick<Stitch<TStitcher['output']>, 'input' | 'output'>> | Pick<Stitch<TStitcher['output']>, 'input' | 'output'>;
+    /**
+     * .what = which thread will receive the stitch
+     */
+    stitchee: keyof TStitcher['threads'];
+}
+export declare class StitchStepCompute<TStitcher extends GStitcher<Threads<any, any>, any, any>> extends DomainLiteral<StitchStepCompute<TStitcher>> implements StitchStepCompute<TStitcher> {
+}
+/**
+ * .what = a step by which to stitch, via imagination
+ */
+export interface StitchStepImagine<TStitcher extends GStitcher<Threads<any, any>, any, any>> extends StitcherBase<StitcherForm.IMAGINE> {
+    /**
+     * .what = which thread will receive the stitch
+     */
+    stitchee: keyof TStitcher['threads'];
+    /**
+     * .what = encodes threads into a prompt
+     */
+    enprompt: (input: {
+        threads: TStitcher['threads'];
+    }) => string;
+    /**
+     * .what = invokes an llm to imagine based on a prompt
+     */
+    imagine: (input: string, context: TStitcher['context']) => Promise<string>;
+    /**
+     * .what = decodes the imagined prompt into a stitch
+     */
+    deprompt: (input: {
+        threads: TStitcher['threads'];
+        promptOut: string;
+        promptIn: string;
+    }) => Pick<Stitch<TStitcher['output']>, 'input' | 'output'>;
+}
+export declare class StitchStepImagine<TStitcher extends GStitcher<Threads<any, any>, any, any>> extends DomainLiteral<StitchStepImagine<TStitcher>> implements StitchStepImagine<TStitcher> {
+}
+/**
+ * .what = a single step that can be stitched
+ * .note = may be computed or imagined
+ */
+export type StitchStep<TStitcher extends GStitcher<Threads<any, any>, any, any>> = StitchStepCompute<TStitcher> | StitchStepImagine<TStitcher>;

package/dist/domain/objects/StitchStep.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StitchStepImagine = exports.StitchStepCompute = void 0;
+const domain_objects_1 = require("domain-objects");
+class StitchStepCompute extends domain_objects_1.DomainLiteral {
+}
+exports.StitchStepCompute = StitchStepCompute;
+class StitchStepImagine extends domain_objects_1.DomainLiteral {
+}
+exports.StitchStepImagine = StitchStepImagine;
+//# sourceMappingURL=StitchStep.js.map

package/dist/domain/objects/StitchStep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StitchStep.js","sourceRoot":"","sources":["../../../src/domain/objects/StitchStep.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AA4B/C,MAAa,iBAGX,SAAQ,8BAA2C;CACT;AAJ5C,8CAI4C;AAiC5C,MAAa,iBAGX,SAAQ,8BAA2C;CACT;AAJ5C,8CAI4C"}

package/dist/domain/objects/StitchTrail.d.ts

@@ -0,0 +1,26 @@
+import { DomainLiteral } from 'domain-objects';
+/**
+ * .what = a trail marker of a stitch
+ */
+export interface StitchTrailMarker {
+    stitchUuid: string;
+    stitcherSlug: string;
+}
+export declare class StitchTrailMarker extends DomainLiteral<StitchTrailMarker> implements StitchTrailMarker {
+}
+/**
+ * .what = a trail of references to stitches that were set
+ */
+export type StitchTrail = StitchTrailMarker[];
+/**
+ * .what = a grokable description of the trail
+ */
+export type StitchTrailDesc = string;
+/**
+ * .what = converts a stitch trail into a human-readable description
+ * .why = used for logging and debugging
+ * .format = joined list of stitcher slugs, e.g., "@root(3126498) > @pick-color(1234567) > @match-paint(7351395)"
+ */
+export declare const asStitchTrailDesc: (input: {
+    trail: StitchTrail;
+}) => StitchTrailDesc;

package/dist/domain/objects/StitchTrail.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asStitchTrailDesc = exports.StitchTrailMarker = void 0;
+const domain_objects_1 = require("domain-objects");
+class StitchTrailMarker extends domain_objects_1.DomainLiteral {
+}
+exports.StitchTrailMarker = StitchTrailMarker;
+/**
+ * .what = converts a stitch trail into a human-readable description
+ * .why = used for logging and debugging
+ * .format = joined list of stitcher slugs, e.g., "@root(3126498) > @pick-color(1234567) > @match-paint(7351395)"
+ */
+const asStitchTrailDesc = (input) => {
+    return input.trail
+        .map((marker) => `@${marker.stitcherSlug}(${marker.stitchUuid.slice(0, 7)})`)
+        .join(' > ');
+};
+exports.asStitchTrailDesc = asStitchTrailDesc;
+//# sourceMappingURL=StitchTrail.js.map

package/dist/domain/objects/StitchTrail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StitchTrail.js","sourceRoot":"","sources":["../../../src/domain/objects/StitchTrail.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AAS/C,MAAa,iBACX,SAAQ,8BAAgC;CACT;AAFjC,8CAEiC;AAYjC;;;;GAIG;AACI,MAAM,iBAAiB,GAAG,CAAC,KAEjC,EAAmB,EAAE;IACpB,OAAO,KAAK,CAAC,KAAK;SACf,GAAG,CACF,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,YAAY,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CACxE;SACA,IAAI,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC,CAAC;AARW,QAAA,iBAAiB,qBAQ5B"}

package/dist/domain/objects/Stitcher.d.ts

@@ -0,0 +1,105 @@
+import { ContextLogTrail } from 'as-procedure';
+import { Literalize } from 'type-fns';
+import { ContextStitchTrail } from '../../logic/stitch/withStitchTrail';
+import { StitchChoice } from './StitchChoice';
+import { StitchCycle } from './StitchCycle';
+import { StitchFanout } from './StitchFanout';
+import { StitchRoute } from './StitchRoute';
+import { StitchStep } from './StitchStep';
+import { Threads } from './Threads';
+/**
+ * .what = the common generics of a stitcher
+ */
+export type GStitcher<TThreads extends Threads<any, any> = Threads<any, 'single'>, TContext extends ContextLogTrail & ContextStitchTrail = ContextLogTrail & ContextStitchTrail, TOutput = any> = {
+    threads: TThreads;
+    context: TContext;
+    output: TOutput;
+};
+/**
+ * .what = the canonical set of stitcher forms
+ */
+export declare enum StitcherForm {
+    /**
+     * .what = a stitch step executed via computation of procedural logic
+     */
+    COMPUTE = "COMPUTE",
+    /**
+     * .what = a stitch step executed via imagination of an llm
+     */
+    IMAGINE = "IMAGINE",
+    /**
+     * .what = a stitch combo via linear sequence
+     */
+    ROUTE = "ROUTE",
+    /**
+     * .what = a stitch combo via parallel fanout + fanin
+     */
+    FANOUT = "FANOUT",
+    /**
+     * .what = a stitch combo via conditional stitcher selection
+     */
+    CHOICE = "CHOICE",
+    /**
+     * .what = a stitch combo via repetition of stitchers
+     */
+    CYCLE = "CYCLE",
+    /**
+     * .what = a stitch combo which gracefully awaits some condition to be satisfied
+     */
+    AWAIT = "AWAIT"
+}
+export declare const isOfStitcherForm: import("type-fns").AssessWithAssure<string | number | symbol, StitcherForm>;
+/**
+ * .what = a generic stitcher which can be executed
+ * .why =
+ *   - generalizes references to atomic StitchSteps or composite StitchRoutes, StitchFanouts, etc
+ *   - enables universal, recursive operations against both atomic and composite stitchers, since their contracts are the same
+ *   - guarantees `.form` is defined for all stitcher types to enable disambiguation via runtime narrowage
+ */
+export type Stitcher<T extends GStitcher<Threads<any, 'single'>, any, any> = GStitcher<Threads<any, 'single'>, any, any>> = StitcherBase<StitcherForm> & (StitchStep<T> | StitchRoute<T> | StitchFanout<T> | StitchChoice<T> | StitchCycle<T>);
+/**
+ * .what = an extensible base declaration of a stitcher
+ * .why =
+ *   - ensures all stitchers will conform to desired standards
+ */
+export interface StitcherBase<TForm extends StitcherForm> {
+    /**
+     * .what = used to disambiguate and narrow which shape of stitcher it is
+     */
+    form: Literalize<TForm>;
+    /**
+     * .what = a unique identifier for this particular stitcher
+     * .why =
+     *   - enables traces via trail markers
+     *   - enables unique key references and equality comparisons
+     */
+    slug: string;
+    /**
+     * .what = a human readable description of the step
+     */
+    readme: string | null;
+}
+/**
+ * .what = an observable description of a stitcher
+ * .why =
+ *   - used to summarize a stitcher
+ * .note =
+ *    - the readme will often be truncated to top 210 char. goal = max(signal to noise)!
+ */
+export type StitcherDesc<TForm extends StitcherForm> = Pick<StitcherBase<TForm>, 'slug' | 'readme' | 'form'>;
+/**
+ * .what = converts a full stitcher into a StitcherDesc
+ * .why = used for observability and trail markers
+ */
+export declare const asStitcherDesc: <TStitcher extends StitcherBase<any>>(input: {
+    stitcher: TStitcher;
+}) => StitcherDesc<TStitcher['form']>;
+/**
+ * .what = extracts the GStitcher generic from a Stitcher
+ * .why = enables typed access to threads, context, and output shape of a Stitcher instance
+ */
+export type GStitcherOf<T> = [T] extends [Stitcher<infer G>] ? G : never;
+/**
+ * .what = flattens a gstitcher's type declaration
+ */
+export type GStitcherFlat<T> = T extends GStitcher<infer Threads, infer Context, infer Output> ? GStitcher<Threads, Context, Output> : never;