@toolproof-core/lib 1.0.29 → 1.0.30

package/dist/artifacts/artifacts.d.ts

@@ -0,0 +1,175 @@
+export declare const CONSTANTS: {
+    readonly Persistence: {
+        readonly Buckets: {
+            readonly tp_resources: "tp-resources";
+            readonly tp_strategies: "tp-strategies";
+        };
+        readonly Collections: {
+            readonly resources: "resources";
+            readonly members: "members";
+        };
+    };
+    readonly Engine: {
+        readonly Graphs: {
+            readonly GraphRunStrategy: "GraphRunStrategy";
+            readonly GraphBuildStrategy: "GraphBuildStrategy";
+        };
+    };
+    readonly Cosmos: {
+        readonly TYPE_Boolean: "TYPE-Boolean";
+        readonly TYPE_Natural: "TYPE-Natural";
+        readonly TYPE_ResourceType: "TYPE-ResourceType";
+        readonly TYPE_Tool: "TYPE-Tool";
+        readonly TYPE_Error: "TYPE-Error";
+        readonly TYPE_RawStrategy: "TYPE-RawStrategy";
+        readonly TYPE_RunnableStrategy: "TYPE-RunnableStrategy";
+        readonly TYPE_StrategyRun: "TYPE-StrategyRun";
+        readonly ROLE_Manual: "ROLE-Manual";
+        readonly ROLE_ErrorOutput: "ROLE-ErrorOutput";
+        readonly ROLE_BooleanBoomerangIn: "ROLE-BooleanBoomerangIn";
+        readonly ROLE_BooleanBoomerangOut: "ROLE-BooleanBoomerangOut";
+        readonly ROLE_LessThanSource: "ROLE-LessThanSource";
+        readonly ROLE_LessThanTarget: "ROLE-LessThanTarget";
+        readonly ROLE_LessThanDecision: "ROLE-LessThanDecision";
+        readonly TOOL_BooleanBoomerang: "TOOL-BooleanBoomerang";
+        readonly TOOL_LessThan: "TOOL-LessThan";
+        readonly TOOL_BuilderCreateToolStep: "TOOL-BuilderCreateToolStep";
+        readonly TOOL_BuilderCreateCase: "TOOL-BuilderCreateCase";
+        readonly TOOL_BuilderCreateBranchStep: "TOOL-BuilderCreateBranchStep";
+        readonly TOOL_BuilderCreateForStep: "TOOL-BuilderCreateForStep";
+        readonly TOOL_BuilderCreateWhileStep: "TOOL-BuilderCreateWhileStep";
+    };
+    readonly Names: {
+        readonly Boolean: "Boolean";
+        readonly BranchStep: "BranchStep";
+        readonly BranchStepId: "BranchStepId";
+        readonly Case: "Case";
+        readonly CreationContext: "CreationContext";
+        readonly CreationContextFacet: "CreationContextFacet";
+        readonly Description: "Description";
+        readonly DescriptionFacet: "DescriptionFacet";
+        readonly DocumentationSpec: "DocumentationSpec";
+        readonly Error: "Error";
+        readonly ExternalInputPotentialShell: "ExternalInputPotentialShell";
+        readonly ForStep: "ForStep";
+        readonly ForStepId: "ForStepId";
+        readonly Goal: "Goal";
+        readonly GoalId: "GoalId";
+        readonly GraphEndRunEvent: "GraphEndRunEvent";
+        readonly GraphStartRunEvent: "GraphStartRunEvent";
+        readonly InternalInputPotentialShell: "InternalInputPotentialShell";
+        readonly InterruptRunEvent: "InterruptRunEvent";
+        readonly MaterializedShell: "MaterializedShell";
+        readonly MaterializedShellBase: "MaterializedShellBase";
+        readonly Name: "Name";
+        readonly NameFacet: "NameFacet";
+        readonly Natural: "Natural";
+        readonly Nucleus: "Nucleus";
+        readonly NucleusFacet: "NucleusFacet";
+        readonly OutputPotentialShell: "OutputPotentialShell";
+        readonly Path: "Path";
+        readonly PathFacet: "PathFacet";
+        readonly RawStrategy: "RawStrategy";
+        readonly Recognizer: "Recognizer";
+        readonly RecognizerId: "RecognizerId";
+        readonly Resource: "Resource";
+        readonly ResourceId: "ResourceId";
+        readonly ResourceLikeByRole: "ResourceLikeByRole";
+        readonly ResourcePotential: "ResourcePotential";
+        readonly ResourceRole: "ResourceRole";
+        readonly ResourceRoleId: "ResourceRoleId";
+        readonly ResourceRoleValue: "ResourceRoleValue";
+        readonly ResourceShellBase: "ResourceShellBase";
+        readonly ResourceShellKind: "ResourceShellKind";
+        readonly ResourceShellKindFacet: "ResourceShellKindFacet";
+        readonly ResourceType: "ResourceType";
+        readonly ResourceTypeId: "ResourceTypeId";
+        readonly RoleBindingArray: "RoleBindingArray";
+        readonly RoleBindingSpec: "RoleBindingSpec";
+        readonly RoleBindingSpecFacet: "RoleBindingSpecFacet";
+        readonly RoleSpec: "RoleSpec";
+        readonly RoleSpecFacet: "RoleSpecFacet";
+        readonly RoleValueById: "RoleValueById";
+        readonly RunEvent: "RunEvent";
+        readonly RunEventBase: "RunEventBase";
+        readonly RunEventCounterSnapshot: "RunEventCounterSnapshot";
+        readonly RunEventDelta: "RunEventDelta";
+        readonly RunEventKind: "RunEventKind";
+        readonly RunEventStepMetadata: "RunEventStepMetadata";
+        readonly RunnableStrategy: "RunnableStrategy";
+        readonly RunnableStrategyFacet: "RunnableStrategyFacet";
+        readonly RunnableStrategyId: "RunnableStrategyId";
+        readonly Step: "Step";
+        readonly StepArray: "StepArray";
+        readonly StepArrayByStrategyThread: "StepArrayByStrategyThread";
+        readonly StepId: "StepId";
+        readonly StepKind: "StepKind";
+        readonly StepKindFacet: "StepKindFacet";
+        readonly StepsByStrategyThreadFacet: "StepsByStrategyThreadFacet";
+        readonly StepsFacet: "StepsFacet";
+        readonly StrategyRun: "StrategyRun";
+        readonly StrategyRunId: "StrategyRunId";
+        readonly StrategyState: "StrategyState";
+        readonly StrategyStateFacet: "StrategyStateFacet";
+        readonly StrategyThreadId: "StrategyThreadId";
+        readonly TickRunEvent: "TickRunEvent";
+        readonly Timestamp: "Timestamp";
+        readonly TimestampFacet: "TimestampFacet";
+        readonly Tool: "Tool";
+        readonly ToolId: "ToolId";
+        readonly ToolKind: "ToolKind";
+        readonly ToolStep: "ToolStep";
+        readonly ToolStepId: "ToolStepId";
+        readonly Uri: "Uri";
+        readonly WhileStep: "WhileStep";
+        readonly WhileStepId: "WhileStepId";
+    };
+    readonly Enums: {
+        readonly ResourceShellKind: {
+            readonly externalInputPotential: "externalInputPotential";
+            readonly internalInputPotential: "internalInputPotential";
+            readonly outputPotential: "outputPotential";
+            readonly materialized: "materialized";
+        };
+        readonly RunEventKind: {
+            readonly graph_start: "graph_start";
+            readonly tick: "tick";
+            readonly interrupt: "interrupt";
+            readonly graph_end: "graph_end";
+        };
+        readonly StepKind: {
+            readonly tool: "tool";
+            readonly branch: "branch";
+            readonly while: "while";
+            readonly for: "for";
+        };
+        readonly ToolKind: {
+            readonly runtime: "runtime";
+            readonly buildtime: "buildtime";
+        };
+    };
+};
+export declare const MAPPINGS: {
+    readonly IdNameToIdPrefix: {
+        readonly BranchStepId: "BRANCH_STEP-";
+        readonly ForStepId: "FOR_STEP-";
+        readonly GoalId: "GOAL-";
+        readonly RecognizerId: "RECOGNIZER-";
+        readonly ResourceId: "RESOURCE-";
+        readonly ResourceRoleId: "ROLE-";
+        readonly ResourceTypeId: "TYPE-";
+        readonly RunnableStrategyId: "RUNNABLE_STRATEGY-";
+        readonly StrategyRunId: "STRATEGY_RUN-";
+        readonly StrategyThreadId: "STRATEGY_THREAD-";
+        readonly ToolId: "TOOL-";
+        readonly ToolStepId: "TOOL_STEP-";
+        readonly WhileStepId: "WHILE_STEP-";
+    };
+    readonly StepKindToStepIdPrefix: {
+        readonly branch: "BRANCH_STEP-";
+        readonly for: "FOR_STEP-";
+        readonly tool: "TOOL_STEP-";
+        readonly while: "WHILE_STEP-";
+    };
+};
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/integrations/firebase/createRunnableStrategy.d.ts

@@ -0,0 +1,3 @@
+import type { RawStrategyJson, RunnableStrategyJson } from '@toolproof-core/schema';
+export declare function createRunnableStrategy(rawStrategy: RawStrategyJson): RunnableStrategyJson;
+//# sourceMappingURL=createRunnableStrategy.d.ts.map

package/dist/integrations/firebase/createStep.d.ts

@@ -0,0 +1,11 @@
+import type { BranchStepJson, ForStepJson, ToolJson, ToolStepJson, WhileStepJson } from '@toolproof-core/schema';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+export declare function createToolStepFromTool(tool: ToolJson): ToolStepJson;
+export declare function createLoopStepFromToolPair(whatTool: ToolJson, whenTool: ToolJson, stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while): ForStepJson | WhileStepJson;
+export declare function createBranchStepFromToolPairs(cases: Array<{
+    whatTool: ToolJson;
+    whenTool: ToolJson;
+}>): BranchStepJson;
+export declare function cloneForStep(forStep: ForStepJson): ForStepJson;
+export declare function cloneWhileStep(whileStep: WhileStepJson): WhileStepJson;
+//# sourceMappingURL=createStep.d.ts.map

package/dist/integrations/firebase/firebaseAdminInit.d.ts

@@ -0,0 +1,4 @@
+declare const dbAdmin: FirebaseFirestore.Firestore;
+declare const storageAdmin: import("firebase-admin/storage").Storage;
+export { dbAdmin, storageAdmin };
+//# sourceMappingURL=firebaseAdminInit.d.ts.map

package/dist/integrations/firebase/firebaseAdminInit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firebaseAdminInit.d.ts","sourceRoot":"","sources":["../../../src/integrations/firebase/firebaseAdminInit.ts"],"names":[],"mappings":"AAmCA,QAAA,MAAM,OAAO,6BAAoB,CAAC;AAClC,QAAA,MAAM,YAAY,0CAAkB,CAAC;AAErC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/integrations/firebase/firebaseAdminInit.js

@@ -0,0 +1,33 @@
+import { getApp, getApps, initializeApp, applicationDefault, cert } from 'firebase-admin/app';
+import { getFirestore } from 'firebase-admin/firestore';
+import { getStorage } from 'firebase-admin/storage';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+function resolveCredential() {
+    const jsonString = process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
+    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+    const localKeyPath = path.join(process.cwd(), 'gcp-key.json');
+    try {
+        if (jsonString) {
+            return cert(JSON.parse(jsonString));
+        }
+        if (envPath && existsSync(envPath)) {
+            return cert(JSON.parse(readFileSync(envPath, 'utf8')));
+        }
+        if (existsSync(localKeyPath)) {
+            return cert(JSON.parse(readFileSync(localKeyPath, 'utf8')));
+        }
+    }
+    catch {
+        return applicationDefault();
+    }
+    return applicationDefault();
+}
+const app = getApps().length ? getApp() : initializeApp({
+    credential: resolveCredential(),
+    projectId: 'toolproof-563fe',
+});
+const dbAdmin = getFirestore(app);
+const storageAdmin = getStorage(app);
+export { dbAdmin, storageAdmin };
+//# sourceMappingURL=firebaseAdminInit.js.map

package/dist/integrations/firebase/firebaseAdminInit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firebaseAdminInit.js","sourceRoot":"","sources":["../../../src/integrations/firebase/firebaseAdminInit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AAC9C,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,SAAS,iBAAiB;IACtB,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC;IACnE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC;IAC3D,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,cAAc,CAAC,CAAC;IAE9D,IAAI,CAAC;QACD,IAAI,UAAU,EAAE,CAAC;YACb,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;QACxC,CAAC;QAED,IAAI,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;QAChE,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,kBAAkB,EAAE,CAAC;IAChC,CAAC;IAED,OAAO,kBAAkB,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,GAAG,GAAG,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;IACpD,UAAU,EAAE,iBAAiB,EAAE;IAC/B,SAAS,EAAE,iBAAiB;CAC/B,CAAC,CAAC;AAEH,MAAM,OAAO,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;AAClC,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;AAErC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/types/types.d.ts

@@ -0,0 +1,18 @@
+import type { StepKindJson, ResourceJson, ResourceTypeIdJson } from '@toolproof-core/schema';
+import { CONSTANTS } from '../artifacts/artifacts.js';
+import { MAPPINGS } from '../artifacts/artifacts.js';
+export type Bucket = typeof CONSTANTS.Persistence.Buckets.tp_resources;
+export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
+export type SchemaLike = Record<string, unknown>;
+export type ResourcesByType = Record<ResourceTypeIdJson, ResourceJson[]>;
+export type IdName = keyof typeof MAPPINGS.IdNameToIdPrefix;
+export type IdStringByIdName<K extends IdName> = `${(typeof MAPPINGS.IdNameToIdPrefix)[K]}${string}`;
+export type StepIdStringByStepKind<K extends StepKindJson> = `${(typeof MAPPINGS.StepKindToStepIdPrefix)[K]}${string}`;
+export interface NucleusBaseSmall<T extends string = string> {
+    id: T;
+}
+export interface NucleusBaseLarge<T extends string = string> extends NucleusBaseSmall<T> {
+    name: string;
+    description: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/bindInputRoleToResource.d.ts

@@ -0,0 +1,5 @@
+import type { CreationContextJson, ResourceJson, StrategyStateJson } from '@toolproof-core/schema';
+export declare function bindInputResInStrategyState(strategyState: StrategyStateJson, target: CreationContextJson, resource: ResourceJson): StrategyStateJson;
+export declare function bindInputRefInStrategyState(strategyState: StrategyStateJson, target: CreationContextJson, source: CreationContextJson): StrategyStateJson;
+export declare function clearInputBindingInStrategyState(strategyState: StrategyStateJson, target: CreationContextJson): StrategyStateJson;
+//# sourceMappingURL=bindInputRoleToResource.d.ts.map

package/dist/utils/creation/runnableStrategyCreation.d.ts

@@ -0,0 +1,4 @@
+import type { RawStrategyJson, RunnableStrategyIdJson, RunnableStrategyJson, StepJson, StrategyThreadIdJson } from '@toolproof-core/schema';
+export declare function getRunnableStrategyThreadGroups(rawStrategy: RawStrategyJson): StepJson[][];
+export declare function buildRunnableStrategy(rawStrategy: RawStrategyJson, runnableStrategyId: RunnableStrategyIdJson, threadStepGroups: StepJson[][], threadIdentities: StrategyThreadIdJson[]): RunnableStrategyJson;
+//# sourceMappingURL=runnableStrategyCreation.d.ts.map

package/dist/utils/creation/stepCreation.d.ts

@@ -0,0 +1,34 @@
+import type { BranchStepIdJson, BranchStepJson, ForStepIdJson, ForStepJson, ToolJson, ToolStepIdJson, ToolStepJson, WhileStepIdJson, WhileStepJson } from '@toolproof-core/schema';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+export type LoopStepBuildIdentities = {
+    stepKind: typeof CONSTANTS.Enums.StepKind.for;
+    stepId: ForStepIdJson;
+    whatId: ToolStepIdJson;
+    whenId: ToolStepIdJson;
+} | {
+    stepKind: typeof CONSTANTS.Enums.StepKind.while;
+    stepId: WhileStepIdJson;
+    whatId: ToolStepIdJson;
+    whenId: ToolStepIdJson;
+};
+export type BranchCaseBuildIdentities = {
+    whatId: ToolStepIdJson;
+    whenId: ToolStepIdJson;
+};
+export declare function buildToolStepFromTool(tool: ToolJson, id: ToolStepIdJson): ToolStepJson;
+export declare function buildLoopStepFromToolPair(whatTool: ToolJson, whenTool: ToolJson, identities: LoopStepBuildIdentities): ForStepJson | WhileStepJson;
+export declare function buildBranchStepFromToolPairs(cases: Array<{
+    whatTool: ToolJson;
+    whenTool: ToolJson;
+}>, branchId: BranchStepIdJson, caseIdentities: BranchCaseBuildIdentities[]): BranchStepJson;
+export declare function cloneForStepWithIdentities(forStep: ForStepJson, identities: {
+    stepId: ForStepIdJson;
+    whatId: ToolStepIdJson;
+    whenId: ToolStepIdJson;
+}): ForStepJson;
+export declare function cloneWhileStepWithIdentities(whileStep: WhileStepJson, identities: {
+    stepId: WhileStepIdJson;
+    whatId: ToolStepIdJson;
+    whenId: ToolStepIdJson;
+}): WhileStepJson;
+//# sourceMappingURL=stepCreation.d.ts.map

package/dist/utils/parallelizeSteps.d.ts

@@ -0,0 +1,3 @@
+import type { StepJson, StrategyStateJson } from '@toolproof-core/schema';
+export declare function getIndependentThreads(steps: StepJson[], strategyState: StrategyStateJson): StepJson[][];
+//# sourceMappingURL=parallelizeSteps.d.ts.map

package/dist/utils/resolveResourceChain.d.ts

@@ -0,0 +1,23 @@
+import type { CreationContextJson, ExternalInputPotentialShellJson, OutputPotentialShellJson, ResourceJson, StrategyStateJson } from '@toolproof-core/schema';
+import { CONSTANTS } from '../artifacts/artifacts.js';
+export type ResolveResult = {
+    status: typeof CONSTANTS.Enums.ResourceShellKind.materialized;
+    entry: ResourceJson;
+    path: CreationContextJson[];
+} | {
+    status: typeof CONSTANTS.Enums.ResourceShellKind.externalInputPotential;
+    entry: ExternalInputPotentialShellJson;
+    path: CreationContextJson[];
+} | {
+    status: typeof CONSTANTS.Enums.ResourceShellKind.outputPotential;
+    entry: OutputPotentialShellJson;
+    path: CreationContextJson[];
+} | {
+    status: 'unresolved';
+    reason: 'not-found' | 'cycle' | 'depth-exceeded';
+    path: CreationContextJson[];
+};
+export declare function resolveResourceChain(strategyState: StrategyStateJson, start: CreationContextJson, opts?: {
+    maxDepth?: number;
+}): ResolveResult;
+//# sourceMappingURL=resolveResourceChain.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.29",
+  "version": "1.0.30",
   "description": "",
   "type": "module",
   "keywords": [],