@toolproof-npm/shared 0.1.82 → 0.1.85

package/dist/_lib/types.d.ts

@@ -8,7 +8,3 @@ export type Role = {
     identity: ResourceRoleIdentityJson;
 } & ResourceRoleValueJson;
 export type ResourceMap = Record<ResourceTypeIdentityJson, ResourceJson[]>;
-export type PartialResourceMeta = Omit<ResourceJson, 'kind' | 'timestamp' | 'path' | 'extractedData'> & {
-    /** Optional timestamp (for replacing existing resources with same timestamp) */
-    timestamp?: string;
-};

package/dist/_lib/utils/resourceCreation.d.ts

@@ -1,5 +1,4 @@
 import type { ResourceTypeIdentityJson, ResourceJson, ResourcePotentialOutputJson, JsonDataJson } from '@toolproof-npm/schema';
-import type { PartialResourceMeta } from '../types.js';
 /**
  * Generates SHA-256 hash of content
  * @param content The content to hash
@@ -14,46 +13,21 @@ export declare function generateContentHash(content: string): string;
  */
 export declare function generateContentAddressedPath(resourceTypeRef: ResourceTypeIdentityJson, content: string): string;
 /**
- * Creates a materialized resource from a potential-output resource.
- * Converts the potential output to a materialized resource by generating a content-addressed path,
- * assigning the content as extractedData, and creating a timestamp.
+ * Creates a materialized resource from a potential-output resource and content.
+ * Generates a content-addressed path from the content.
  *
  * @param potentialOutput The potential-output resource to materialize
- * @param content The actual content produced by the job (assigned directly to extractedData)
- * @returns A fully materialized ResourceJson
- *
- * @example
- * ```typescript
- * const materialized = createMaterializedResourceFromPotentialOutput(
- *   potentialOutput,
- *   { identity: 42, someData: "result" }
- * );
- * ```
- */
-export declare function createMaterializedResourceFromPotentialOutput(potentialOutput: ResourcePotentialOutputJson, content: JsonDataJson): ResourceJson;
-/**
- * Creates a materialized resource from scratch (for manual resource creation).
- * Generates a content-addressed path from the content and creates a timestamp.
- * Use this when creating resources manually without a potential-output template.
- *
- * @param partialResourceMeta Partial metadata (identity, type, context, optional timestamp)
  * @param content The actual content/data (assigned directly to extractedData)
+ * @param timestamp Optional timestamp to preserve (e.g., when copying resources). If not provided, generates a new timestamp.
  * @returns A fully materialized ResourceJson
  *
  * @example
  * ```typescript
- * const materialized = createMaterializedResourceFromScratch(
- *   {
- *     identity: 'RESOURCE-abc123',
- *     resourceTypeRef: 'TYPE-Natural',
- *     creationContext: {
- *       resourceRoleRef: 'ROLE-Manual',
- *       executionRef: 'EXECUTION-Genesis'
- *     },
- *     timestamp: '2025-01-03T12:00:00.000Z' // optional
- *   },
- *   { identity: 42 }
- * );
+ * // Materialize from potential output
+ * const materialized = createMaterializedResource(potentialOutput, { identity: 42 });
+ *
+ * // Preserve original timestamp when copying
+ * const copy = createMaterializedResource(potentialOutput, { identity: 42 }, originalTimestamp);
  * ```
  */
-export declare function createMaterializedResourceFromScratch(partialResourceMeta: PartialResourceMeta, content: JsonDataJson): ResourceJson;
+export declare function createMaterializedResource(potentialOutput: ResourcePotentialOutputJson, content: JsonDataJson, timestamp?: string): ResourceJson;

package/dist/_lib/utils/resourceCreation.js

@@ -18,63 +18,25 @@ export function generateContentAddressedPath(resourceTypeRef, content) {
     return `${resourceTypeRef}/${contentHash}`;
 }
 /**
- * Creates a materialized resource from a potential-output resource.
- * Converts the potential output to a materialized resource by generating a content-addressed path,
- * assigning the content as extractedData, and creating a timestamp.
+ * Creates a materialized resource from a potential-output resource and content.
+ * Generates a content-addressed path from the content.
  *
  * @param potentialOutput The potential-output resource to materialize
- * @param content The actual content produced by the job (assigned directly to extractedData)
- * @returns A fully materialized ResourceJson
- *
- * @example
- * ```typescript
- * const materialized = createMaterializedResourceFromPotentialOutput(
- *   potentialOutput,
- *   { identity: 42, someData: "result" }
- * );
- * ```
- */
-export function createMaterializedResourceFromPotentialOutput(potentialOutput, content) {
-    // Generate content-addressed path from the content (use compact format for hashing)
-    const contentString = JSON.stringify(content, null, 2);
-    const path = generateContentAddressedPath(potentialOutput.resourceTypeRef, contentString);
-    return {
-        identity: potentialOutput.identity,
-        resourceTypeRef: potentialOutput.resourceTypeRef,
-        creationContext: potentialOutput.creationContext,
-        kind: 'materialized',
-        path,
-        timestamp: new Date().toISOString(),
-        extractedData: content,
-    };
-}
-/**
- * Creates a materialized resource from scratch (for manual resource creation).
- * Generates a content-addressed path from the content and creates a timestamp.
- * Use this when creating resources manually without a potential-output template.
- *
- * @param partialResourceMeta Partial metadata (identity, type, context, optional timestamp)
  * @param content The actual content/data (assigned directly to extractedData)
+ * @param timestamp Optional timestamp to preserve (e.g., when copying resources). If not provided, generates a new timestamp.
  * @returns A fully materialized ResourceJson
  *
  * @example
  * ```typescript
- * const materialized = createMaterializedResourceFromScratch(
- *   {
- *     identity: 'RESOURCE-abc123',
- *     resourceTypeRef: 'TYPE-Natural',
- *     creationContext: {
- *       resourceRoleRef: 'ROLE-Manual',
- *       executionRef: 'EXECUTION-Genesis'
- *     },
- *     timestamp: '2025-01-03T12:00:00.000Z' // optional
- *   },
- *   { identity: 42 }
- * );
+ * // Materialize from potential output
+ * const materialized = createMaterializedResource(potentialOutput, { identity: 42 });
+ *
+ * // Preserve original timestamp when copying
+ * const copy = createMaterializedResource(potentialOutput, { identity: 42 }, originalTimestamp);
  * ```
  */
-export function createMaterializedResourceFromScratch(partialResourceMeta, content) {
-    const { identity, resourceTypeRef, creationContext, timestamp } = partialResourceMeta;
+export function createMaterializedResource(potentialOutput, content, timestamp) {
+    const { identity, resourceTypeRef, creationContext } = potentialOutput;
     // Generate content-addressed path from the content (use pretty-printed format)
     const contentString = JSON.stringify(content, null, 2);
     const path = generateContentAddressedPath(resourceTypeRef, contentString);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/shared",
-  "version": "0.1.82",
+  "version": "0.1.85",
   "description": "Core library utilities for ToolProof",
   "keywords": [
     "toolproof",

package/dist/types.d.ts

@@ -1,19 +0,0 @@
-import type { ExecutionIdentityJson, ResourceIdentityJson, ResourceJson, ResourceRoleIdentityJson, ResourceRoleValueJson, ResourceTypeIdentityJson } from '@toolproof-npm/schema';
-import { CONSTANTS } from './constants.js';
-export type BucketConst = typeof CONSTANTS.STORAGE.BUCKETS.tp_resources;
-export type CollectionConst = keyof typeof CONSTANTS.STORAGE.COLLECTIONS;
-export type TerminalConst = keyof typeof CONSTANTS.TERMINALS;
-export type StepConst = keyof typeof CONSTANTS.STEPS;
-export type Role = {
-    identity: ResourceRoleIdentityJson;
-} & ResourceRoleValueJson;
-export type ResourceMap = Record<ResourceTypeIdentityJson, ResourceJson[]>;
-export type PartialResourceMeta = {
-    identity: ResourceIdentityJson;
-    resourceTypeRef: ResourceTypeIdentityJson;
-    creationContext: {
-        resourceRoleRef: ResourceRoleIdentityJson;
-        executionRef: ExecutionIdentityJson;
-    };
-    timestamp?: string;
-};

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils.d.ts

@@ -1,24 +0,0 @@
-import type { ResourceIdentityJson, ResourceTypeIdentityJson, ResourceJson, ResourceMissingJson, JobJson, ResourcePotentialOutputJson, StrategyStateJson, CreationContextJson } from '@toolproof-npm/schema';
-import type { ResourceMap } from './types.js';
-export declare function extractResourcesByType(resourceMap: ResourceMap, resourceTypeRef: ResourceTypeIdentityJson): Record<ResourceIdentityJson, ResourceJson>;
-export declare function extractJobMap(resourceMap: ResourceMap): Map<`JOB-${string}`, JobJson>;
-export type ResolveResult = {
-    status: 'materialized';
-    entry: ResourceJson;
-    path: CreationContextJson[];
-} | {
-    status: 'missing';
-    entry: ResourceMissingJson;
-    path: CreationContextJson[];
-} | {
-    status: 'blocked-output';
-    entry: ResourcePotentialOutputJson;
-    path: CreationContextJson[];
-} | {
-    status: 'unresolved';
-    reason: 'missing-entry' | 'cycle' | 'depth-exceeded';
-    path: CreationContextJson[];
-};
-export declare function resolveResourceChain(strategyState: StrategyStateJson, start: CreationContextJson, opts?: {
-    maxDepth?: number;
-}): ResolveResult;

package/dist/utils.js

@@ -1,58 +0,0 @@
-export function extractResourcesByType(resourceMap, resourceTypeRef) {
-    const resources = resourceMap[resourceTypeRef] ?? [];
-    const result = {};
-    for (const resource of resources) {
-        result[resource.identity] = resource;
-    }
-    return result;
-}
-export function extractJobMap(resourceMap) {
-    const resourceJobMap = extractResourcesByType(resourceMap, 'TYPE-Job');
-    const jobMap = new Map();
-    Object.values(resourceJobMap).forEach((resource) => {
-        if (resource.extractedData?.identity) {
-            jobMap.set(resource.extractedData.identity, resource.extractedData); // ATTENTION: why do we need type assertion here?
-        }
-    });
-    return jobMap;
-}
-export function resolveResourceChain(strategyState, start, opts) {
-    const maxDepth = opts?.maxDepth ?? 50;
-    const visited = new Set();
-    const path = [];
-    let current = start;
-    for (let depth = 0; depth <= maxDepth; depth++) {
-        path.push(current);
-        const visitKey = `${current.executionRef}::${current.resourceRoleRef}`;
-        if (visited.has(visitKey)) {
-            return { status: 'unresolved', reason: 'cycle', path };
-        }
-        visited.add(visitKey);
-        const bucket = strategyState[current.executionRef];
-        if (!bucket)
-            return { status: 'unresolved', reason: 'missing-entry', path };
-        const entry = bucket[current.resourceRoleRef];
-        if (!entry)
-            return { status: 'unresolved', reason: 'missing-entry', path };
-        if (entry.kind === 'materialized') {
-            return { status: 'materialized', entry: entry, path };
-        }
-        if (entry.kind === 'missing') {
-            return { status: 'missing', entry: entry, path };
-        }
-        if (entry.kind === 'potential-output') {
-            return { status: 'blocked-output', entry: entry, path };
-        }
-        // potential-input: follow ref backwards
-        if (entry.kind === 'potential-input') {
-            const rpi = entry.creationContext;
-            if (!rpi)
-                return { status: 'unresolved', reason: 'missing-entry', path };
-            current = rpi;
-            continue;
-        }
-        // Unknown case
-        return { status: 'unresolved', reason: 'missing-entry', path };
-    }
-    return { status: 'unresolved', reason: 'depth-exceeded', path };
-}