@cascaide-ts/postgres-js 0.1.0 → 0.5.1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2026 Cascaide
+Copyright (c) 2026 Jishnu K Ramakrishnan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,29 @@
+# @cascaide-ts/postgres-js
+
+Cascaide is a fullstack agent runtime and AI orchestration framework in typescript.
+
+`cascaide-ts/postgres-js` provides the postgres backed durability layer for cascade executions. Used to create the persistence api route.
+
+
+## Installation 
+
+```bash 
+npm i @cascaide-ts/postgres-js
+```
+
+## Example Use
+
+```ts 
+import { createPersistenceHandler } from '@cascaide-ts/server-next';
+import { PostgresPersistor } from '@cascaide-ts/postgres-js';
+import { sql } from '@/lib/pglite';
+
+const persistor = new PostgresPersistor(sql);
+export const POST =createPersistenceHandler(persistor);
+
+```
+
+## Additional Resources
+
+[Pesistence Concepts](https://www.cascaide-ts.com/docs/capabilities/persistence)
+[Persistence Setup](https://www.cascaide-ts.com/docs/QuickStart/db)

package/dist/index.cjs

@@ -1,4 +1,4 @@
-var l=Object.defineProperty;var I=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var x=(r,t)=>{for(var a in t)l(r,a,{get:t[a],enumerable:!0})},R=(r,t,a,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of T(t))!C.call(r,e)&&e!==a&&l(r,e,{get:()=>t[e],enumerable:!(n=I(t,e))||n.enumerable});return r};var S=r=>R(l({},"__esModule",{value:!0}),r);var y={};x(y,{PostgresPersistor:()=>u});module.exports=S(y);var f=require("crypto"),u=class{constructor(t){this.sql=t}async claimNodeExecution(t){let a=performance.now(),{nodeInstanceId:n,cascadeId:e,userId:s,nodeName:c,functionId:o,inputContext:d,location:i}=t;console.log("Claiming node execution:",{cascadeId:e,nodeName:c,requestedId:o});let _=(0,f.randomUUID)(),m=await this.sql.begin(async N=>{let E=await N`
+var E=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var C=(u,e)=>{for(var r in e)E(u,r,{get:e[r],enumerable:!0})},R=(u,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of I(e))!T.call(u,t)&&t!==r&&E(u,t,{get:()=>e[t],enumerable:!(n=m(e,t))||n.enumerable});return u};var S=u=>R(E({},"__esModule",{value:!0}),u);var y={};C(y,{PostgresPersistor:()=>_});module.exports=S(y);var f=require("crypto"),x=process.env.NODE_ENV==="development",O=(...u)=>{x&&console.log(...u)};var _=class{constructor(e){this.sql=e}sql;async claimNodeExecution(e){let r=performance.now(),{nodeInstanceId:n,cascadeId:t,userId:c,nodeName:i,functionId:o,inputContext:a,location:s}=e;O("Claiming node execution:",{cascadeId:t,nodeName:i,requestedId:o});let d=(0,f.randomUUID)(),N=await this.sql.begin(async p=>{let l=await p`
         WITH conflict_check AS (
           -- Single aggregation combining conflict detection and MAX calculation
           -- More efficient than separate EXISTS and MAX queries
@@ -9,11 +9,11 @@ var l=Object.defineProperty;var I=Object.getOwnPropertyDescriptor;var T=Object.g
               ELSE ${o}
             END as next_fn_id
           FROM node_executions 
-          WHERE cascade_id = ${e}
+          WHERE cascade_id = ${t}
         ),
         cascade_upsert AS (
           INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
-          SELECT ${e}, ${s}, 'RUNNING', next_fn_id, NOW(), NOW()
+          SELECT ${t}, ${c}, 'RUNNING', next_fn_id, NOW(), NOW()
           FROM conflict_check
           ON CONFLICT (id) DO UPDATE 
             SET fn_id = EXCLUDED.fn_id, updated_at = NOW()
@@ -31,23 +31,23 @@ var l=Object.defineProperty;var I=Object.getOwnPropertyDescriptor;var T=Object.g
           started_at
         )
         SELECT 
-          ${_}, 
+          ${d}, 
           ${n}, 
-          ${e}, 
-          ${c}, 
-          fn_id, 
-          ${this.sql.json(d)}, 
+          ${t}, 
           ${i}, 
+          fn_id, 
+          ${this.sql.json(a)}, 
+          ${s}, 
           'RUNNING', 
           NOW()
         FROM cascade_upsert
         RETURNING status, function_id as "functionId"
-      `;return{status:E[0].status,functionId:Number(E[0].functionId)}}),p=performance.now()-a;return console.log(`claimNodeExecution latency: ${p.toFixed(2)}ms`,{cascadeId:e,nodeName:c}),m}async finalizeNodeExecution(t){let a=performance.now(),{nodeInstanceId:n,cascadeId:e,fullOutput:s,hasSpawns:c}=t,o=await this.sql.begin(async i=>(await i`
+      `;return{status:l[0].status,functionId:Number(l[0].functionId)}}),g=performance.now()-r;return N}async finalizeNodeExecution(e){let r=performance.now(),{nodeInstanceId:n,cascadeId:t,fullOutput:c,hasSpawns:i}=e;return await this.sql.begin(async a=>(await a`
         WITH updated_node AS (
           UPDATE node_executions
           SET 
             status = 'COMPLETED',
-            full_output = ${this.sql.json(s)},
+            full_output = ${this.sql.json(c)},
             completed_at = NOW()
           WHERE node_instance_id = ${n}
           RETURNING cascade_id
@@ -55,82 +55,72 @@ var l=Object.defineProperty;var I=Object.getOwnPropertyDescriptor;var T=Object.g
         UPDATE cascades
         SET status = 'COMPLETED', updated_at = NOW()
         WHERE id IN (SELECT cascade_id FROM updated_node)
-          AND ${!c}
-      `,{status:"COMPLETED"})),d=performance.now()-a;return console.log(`finalizeNodeExecution latency: ${d.toFixed(2)}ms`,{cascadeId:e,nodeInstanceId:n}),o}async markExecutionFailed(t,a,n){let e=performance.now(),s=await this.sql.begin(async o=>(await o`
+          AND ${!i}
+      `,{status:"COMPLETED"}))}async markExecutionFailed(e,r,n){let t=performance.now();return await this.sql.begin(async i=>(await i`
         WITH updated_node AS (
           UPDATE node_executions
           SET status = 'FAILED', error = ${n}, completed_at = NOW()
-          WHERE node_instance_id = ${t}
+          WHERE node_instance_id = ${e}
           RETURNING cascade_id
         )
         UPDATE cascades
         SET status = 'ERROR', updated_at = NOW()
         WHERE id IN (SELECT cascade_id FROM updated_node)
-      `,{status:"FAILED"})),c=performance.now()-e;return console.log(`markExecutionFailed latency: ${c.toFixed(2)}ms`,{cascadeId:a,nodeInstanceId:t}),s}async recordContextEvents(t){let a=performance.now(),{cascadeId:n,functionId:e,updates:s}=t,c=Object.entries(s).map(([d,i])=>({key:d,value:this.sql.json(i),function_id:e,cascade_id:n,created_at:new Date}));if(c.length===0){let d=performance.now()-a;return console.log(`recordContextEvents latency: ${d.toFixed(2)}ms (no events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}await this.sql`
-      INSERT INTO context_events ${this.sql(c,"key","value","function_id","cascade_id","created_at")}
-    `;let o=performance.now()-a;return console.log(`recordContextEvents latency: ${o.toFixed(2)}ms (${c.length} events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}async hydrateCascadeContext(t,a){let n=performance.now(),e=await this.sql`
-      SELECT key, value, function_id, created_at
-      FROM context_events
-      WHERE cascade_id = ${t}
-        AND function_id < ${a}
-      ORDER BY function_id ASC, created_at ASC
-    `,s={};for(let o of e){let d=o.key,i=o.value;if(s[d]||(s[d]=[]),typeof i=="object"&&i!==null&&!Array.isArray(i)&&"index"in i){let _=i.index;s[d][_]=i}else s[d].push(i)}let c=performance.now()-n;return console.log(`hydrateCascadeContext latency: ${c.toFixed(2)}ms (${e.length} events)`,{cascadeId:t,upToFunctionId:a}),s}async forkCascade(t){let a=performance.now(),{sourceCascadeId:n,newCascadeId:e,upToFunctionId:s}=t;await this.sql.begin(async o=>{await o`
+      `,{status:"FAILED"}))}async recordContextEvents(e){let r=performance.now(),{cascadeId:n,functionId:t,updates:c,uiUpdates:i}=e,o=Object.entries(c).map(([a,s])=>{let d=i?.[a];return{key:a,value:this.sql.json(s),ui_value:d!==void 0?this.sql.json(d):null,function_id:t,cascade_id:n,created_at:new Date}});return o.length===0?{status:"SUCCESS"}:(await this.sql`
+      INSERT INTO context_events ${this.sql(o,"key","value","ui_value","function_id","cascade_id","created_at")}
+    `,{status:"SUCCESS"})}async hydrateCascadeContext(e,r,n){let t=performance.now(),c;n?c=await this.sql`
+        SELECT 
+          key, 
+          COALESCE(ui_value, value) AS value, 
+          function_id, 
+          created_at
+        FROM context_events
+        WHERE cascade_id = ${e}
+          AND function_id < ${r}
+        ORDER BY function_id ASC, created_at ASC
+      `:c=await this.sql`
+        SELECT 
+          key, 
+          value, 
+          function_id, 
+          created_at
+        FROM context_events
+        WHERE cascade_id = ${e}
+          AND function_id < ${r}
+        ORDER BY function_id ASC, created_at ASC
+      `;let i={};for(let o of c){let a=o.key,s=o.value;if(i[a]||(i[a]=[]),typeof s=="object"&&s!==null&&!Array.isArray(s)&&"index"in s){let d=s.index;i[a][d]=s}else i[a].push(s)}return i}async forkCascadeWithContext(e){let r=performance.now(),{sourceCascadeId:n,newCascadeId:t,upToFunctionId:c}=e,i=await this.sql.begin(async a=>(await a`
         INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
         SELECT
-          ${e},
+          ${t},
           user_id,
           'RUNNING',
-          ${s-1},
+          ${c-1},
           NOW(),
           NOW()
         FROM cascades
         WHERE id = ${n}
-      `,await o`
+      `,await a`
         INSERT INTO node_executions (
-          id,
-          node_instance_id,
-          cascade_id,
-          node_name,
-          function_id,
-          input_context,
-          location,
-          status,
-          started_at,
-          completed_at,
-          full_output,
-          error
+          id, node_instance_id, cascade_id, node_name, function_id,
+          input_context, location, status, started_at, completed_at, full_output, error
         )
         SELECT
-          gen_random_uuid(),
-          node_instance_id,
-          ${e},
-          node_name,
-          function_id,
-          input_context,
-          location,
-          status,
-          started_at,
-          completed_at,
-          full_output,
-          error
+          gen_random_uuid(), gen_random_uuid(), ${t},
+          node_name, function_id, input_context, location, status,
+          started_at, completed_at, full_output, error
         FROM node_executions
         WHERE cascade_id = ${n}
-          AND function_id < ${s}
-      `,await o`
-        INSERT INTO context_events (
-          key,
-          value,
-          function_id,
-          cascade_id,
-          created_at
-        )
+          AND function_id < ${c}
+      `,await a`
+        INSERT INTO context_events (key, value, function_id, cascade_id, created_at)
         SELECT
-          key,
+          CASE WHEN key = ${n} THEN ${t} ELSE key END,
           value,
           function_id,
-          ${e},
+          ${t},
           created_at
         FROM context_events
         WHERE cascade_id = ${n}
-          AND function_id < ${s}
-      `});let c=performance.now()-a;return console.log(`forkCascade latency: ${c.toFixed(2)}ms`,{sourceCascadeId:n,newCascadeId:e,upToFunctionId:s}),{newCascadeId:e,status:"SUCCESS"}}};0&&(module.exports={PostgresPersistor});
+          AND function_id < ${c}
+        RETURNING key, value, function_id, created_at
+      `)),o={};for(let a of i){let{key:s,value:d}=a;o[s]||(o[s]=[]),typeof d=="object"&&d!==null&&!Array.isArray(d)&&"index"in d?o[s][d.index]=d:o[s].push(d)}return{newCascadeId:t,status:"SUCCESS",context:o}}};0&&(module.exports={PostgresPersistor});

package/dist/index.d.cts

@@ -23,17 +23,21 @@ declare class PostgresPersistor implements CascadePersistence {
         updates: {
             [key: string]: any;
         };
+        uiUpdates?: {
+            [key: string]: any;
+        };
     }): Promise<{
         status: string;
     }>;
-    hydrateCascadeContext(cascadeId: string, upToFunctionId: number): Promise<WorkflowContext>;
-    forkCascade(params: {
+    hydrateCascadeContext(cascadeId: string, upToFunctionId: number, ui?: boolean): Promise<WorkflowContext>;
+    forkCascadeWithContext(params: {
         sourceCascadeId: string;
         newCascadeId: string;
         upToFunctionId: number;
     }): Promise<{
         newCascadeId: string;
         status: string;
+        context: WorkflowContext;
     }>;
 }
 

package/dist/index.d.ts

@@ -23,17 +23,21 @@ declare class PostgresPersistor implements CascadePersistence {
         updates: {
             [key: string]: any;
         };
+        uiUpdates?: {
+            [key: string]: any;
+        };
     }): Promise<{
         status: string;
     }>;
-    hydrateCascadeContext(cascadeId: string, upToFunctionId: number): Promise<WorkflowContext>;
-    forkCascade(params: {
+    hydrateCascadeContext(cascadeId: string, upToFunctionId: number, ui?: boolean): Promise<WorkflowContext>;
+    forkCascadeWithContext(params: {
         sourceCascadeId: string;
         newCascadeId: string;
         upToFunctionId: number;
     }): Promise<{
         newCascadeId: string;
         status: string;
+        context: WorkflowContext;
     }>;
 }
 

package/dist/index.js

@@ -1,4 +1,4 @@
-import{randomUUID as m}from"crypto";var u=class{constructor(o){this.sql=o}async claimNodeExecution(o){let c=performance.now(),{nodeInstanceId:n,cascadeId:e,userId:t,nodeName:s,functionId:a,inputContext:d,location:i}=o;console.log("Claiming node execution:",{cascadeId:e,nodeName:s,requestedId:a});let r=m(),l=await this.sql.begin(async f=>{let _=await f`
+import{randomUUID as N}from"crypto";var p=process.env.NODE_ENV==="development",m=(..._)=>{p&&console.log(..._)};var u=class{constructor(d){this.sql=d}sql;async claimNodeExecution(d){let r=performance.now(),{nodeInstanceId:i,cascadeId:s,userId:o,nodeName:n,functionId:a,inputContext:e,location:t}=d;m("Claiming node execution:",{cascadeId:s,nodeName:n,requestedId:a});let c=N(),l=await this.sql.begin(async f=>{let E=await f`
         WITH conflict_check AS (
           -- Single aggregation combining conflict detection and MAX calculation
           -- More efficient than separate EXISTS and MAX queries
@@ -9,11 +9,11 @@ import{randomUUID as m}from"crypto";var u=class{constructor(o){this.sql=o}async
               ELSE ${a}
             END as next_fn_id
           FROM node_executions 
-          WHERE cascade_id = ${e}
+          WHERE cascade_id = ${s}
         ),
         cascade_upsert AS (
           INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
-          SELECT ${e}, ${t}, 'RUNNING', next_fn_id, NOW(), NOW()
+          SELECT ${s}, ${o}, 'RUNNING', next_fn_id, NOW(), NOW()
           FROM conflict_check
           ON CONFLICT (id) DO UPDATE 
             SET fn_id = EXCLUDED.fn_id, updated_at = NOW()
@@ -31,106 +31,96 @@ import{randomUUID as m}from"crypto";var u=class{constructor(o){this.sql=o}async
           started_at
         )
         SELECT 
-          ${r}, 
-          ${n}, 
-          ${e}, 
+          ${c}, 
+          ${i}, 
           ${s}, 
+          ${n}, 
           fn_id, 
-          ${this.sql.json(d)}, 
-          ${i}, 
+          ${this.sql.json(e)}, 
+          ${t}, 
           'RUNNING', 
           NOW()
         FROM cascade_upsert
         RETURNING status, function_id as "functionId"
-      `;return{status:_[0].status,functionId:Number(_[0].functionId)}}),E=performance.now()-c;return console.log(`claimNodeExecution latency: ${E.toFixed(2)}ms`,{cascadeId:e,nodeName:s}),l}async finalizeNodeExecution(o){let c=performance.now(),{nodeInstanceId:n,cascadeId:e,fullOutput:t,hasSpawns:s}=o,a=await this.sql.begin(async i=>(await i`
+      `;return{status:E[0].status,functionId:Number(E[0].functionId)}}),I=performance.now()-r;return l}async finalizeNodeExecution(d){let r=performance.now(),{nodeInstanceId:i,cascadeId:s,fullOutput:o,hasSpawns:n}=d;return await this.sql.begin(async e=>(await e`
         WITH updated_node AS (
           UPDATE node_executions
           SET 
             status = 'COMPLETED',
-            full_output = ${this.sql.json(t)},
+            full_output = ${this.sql.json(o)},
             completed_at = NOW()
-          WHERE node_instance_id = ${n}
+          WHERE node_instance_id = ${i}
           RETURNING cascade_id
         )
         UPDATE cascades
         SET status = 'COMPLETED', updated_at = NOW()
         WHERE id IN (SELECT cascade_id FROM updated_node)
-          AND ${!s}
-      `,{status:"COMPLETED"})),d=performance.now()-c;return console.log(`finalizeNodeExecution latency: ${d.toFixed(2)}ms`,{cascadeId:e,nodeInstanceId:n}),a}async markExecutionFailed(o,c,n){let e=performance.now(),t=await this.sql.begin(async a=>(await a`
+          AND ${!n}
+      `,{status:"COMPLETED"}))}async markExecutionFailed(d,r,i){let s=performance.now();return await this.sql.begin(async n=>(await n`
         WITH updated_node AS (
           UPDATE node_executions
-          SET status = 'FAILED', error = ${n}, completed_at = NOW()
-          WHERE node_instance_id = ${o}
+          SET status = 'FAILED', error = ${i}, completed_at = NOW()
+          WHERE node_instance_id = ${d}
           RETURNING cascade_id
         )
         UPDATE cascades
         SET status = 'ERROR', updated_at = NOW()
         WHERE id IN (SELECT cascade_id FROM updated_node)
-      `,{status:"FAILED"})),s=performance.now()-e;return console.log(`markExecutionFailed latency: ${s.toFixed(2)}ms`,{cascadeId:c,nodeInstanceId:o}),t}async recordContextEvents(o){let c=performance.now(),{cascadeId:n,functionId:e,updates:t}=o,s=Object.entries(t).map(([d,i])=>({key:d,value:this.sql.json(i),function_id:e,cascade_id:n,created_at:new Date}));if(s.length===0){let d=performance.now()-c;return console.log(`recordContextEvents latency: ${d.toFixed(2)}ms (no events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}await this.sql`
-      INSERT INTO context_events ${this.sql(s,"key","value","function_id","cascade_id","created_at")}
-    `;let a=performance.now()-c;return console.log(`recordContextEvents latency: ${a.toFixed(2)}ms (${s.length} events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}async hydrateCascadeContext(o,c){let n=performance.now(),e=await this.sql`
-      SELECT key, value, function_id, created_at
-      FROM context_events
-      WHERE cascade_id = ${o}
-        AND function_id < ${c}
-      ORDER BY function_id ASC, created_at ASC
-    `,t={};for(let a of e){let d=a.key,i=a.value;if(t[d]||(t[d]=[]),typeof i=="object"&&i!==null&&!Array.isArray(i)&&"index"in i){let r=i.index;t[d][r]=i}else t[d].push(i)}let s=performance.now()-n;return console.log(`hydrateCascadeContext latency: ${s.toFixed(2)}ms (${e.length} events)`,{cascadeId:o,upToFunctionId:c}),t}async forkCascade(o){let c=performance.now(),{sourceCascadeId:n,newCascadeId:e,upToFunctionId:t}=o;await this.sql.begin(async a=>{await a`
+      `,{status:"FAILED"}))}async recordContextEvents(d){let r=performance.now(),{cascadeId:i,functionId:s,updates:o,uiUpdates:n}=d,a=Object.entries(o).map(([e,t])=>{let c=n?.[e];return{key:e,value:this.sql.json(t),ui_value:c!==void 0?this.sql.json(c):null,function_id:s,cascade_id:i,created_at:new Date}});return a.length===0?{status:"SUCCESS"}:(await this.sql`
+      INSERT INTO context_events ${this.sql(a,"key","value","ui_value","function_id","cascade_id","created_at")}
+    `,{status:"SUCCESS"})}async hydrateCascadeContext(d,r,i){let s=performance.now(),o;i?o=await this.sql`
+        SELECT 
+          key, 
+          COALESCE(ui_value, value) AS value, 
+          function_id, 
+          created_at
+        FROM context_events
+        WHERE cascade_id = ${d}
+          AND function_id < ${r}
+        ORDER BY function_id ASC, created_at ASC
+      `:o=await this.sql`
+        SELECT 
+          key, 
+          value, 
+          function_id, 
+          created_at
+        FROM context_events
+        WHERE cascade_id = ${d}
+          AND function_id < ${r}
+        ORDER BY function_id ASC, created_at ASC
+      `;let n={};for(let a of o){let e=a.key,t=a.value;if(n[e]||(n[e]=[]),typeof t=="object"&&t!==null&&!Array.isArray(t)&&"index"in t){let c=t.index;n[e][c]=t}else n[e].push(t)}return n}async forkCascadeWithContext(d){let r=performance.now(),{sourceCascadeId:i,newCascadeId:s,upToFunctionId:o}=d,n=await this.sql.begin(async e=>(await e`
         INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
         SELECT
-          ${e},
+          ${s},
           user_id,
           'RUNNING',
-          ${t-1},
+          ${o-1},
           NOW(),
           NOW()
         FROM cascades
-        WHERE id = ${n}
-      `,await a`
+        WHERE id = ${i}
+      `,await e`
         INSERT INTO node_executions (
-          id,
-          node_instance_id,
-          cascade_id,
-          node_name,
-          function_id,
-          input_context,
-          location,
-          status,
-          started_at,
-          completed_at,
-          full_output,
-          error
+          id, node_instance_id, cascade_id, node_name, function_id,
+          input_context, location, status, started_at, completed_at, full_output, error
         )
         SELECT
-          gen_random_uuid(),
-          node_instance_id,
-          ${e},
-          node_name,
-          function_id,
-          input_context,
-          location,
-          status,
-          started_at,
-          completed_at,
-          full_output,
-          error
+          gen_random_uuid(), gen_random_uuid(), ${s},
+          node_name, function_id, input_context, location, status,
+          started_at, completed_at, full_output, error
         FROM node_executions
-        WHERE cascade_id = ${n}
-          AND function_id < ${t}
-      `,await a`
-        INSERT INTO context_events (
-          key,
-          value,
-          function_id,
-          cascade_id,
-          created_at
-        )
+        WHERE cascade_id = ${i}
+          AND function_id < ${o}
+      `,await e`
+        INSERT INTO context_events (key, value, function_id, cascade_id, created_at)
         SELECT
-          key,
+          CASE WHEN key = ${i} THEN ${s} ELSE key END,
           value,
           function_id,
-          ${e},
+          ${s},
           created_at
         FROM context_events
-        WHERE cascade_id = ${n}
-          AND function_id < ${t}
-      `});let s=performance.now()-c;return console.log(`forkCascade latency: ${s.toFixed(2)}ms`,{sourceCascadeId:n,newCascadeId:e,upToFunctionId:t}),{newCascadeId:e,status:"SUCCESS"}}};export{u as PostgresPersistor};
+        WHERE cascade_id = ${i}
+          AND function_id < ${o}
+        RETURNING key, value, function_id, created_at
+      `)),a={};for(let e of n){let{key:t,value:c}=e;a[t]||(a[t]=[]),typeof c=="object"&&c!==null&&!Array.isArray(c)&&"index"in c?a[t][c.index]=c:a[t].push(c)}return{newCascadeId:s,status:"SUCCESS",context:a}}};export{u as PostgresPersistor};

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@cascaide-ts/postgres-js",
-  "version": "0.1.0",
+  "version": "0.5.1",
+  "license": "MIT",
   "files": [
-    "dist"
+    "dist",
+    "LICENSE",
+    "README.md"
   ],
   "type": "module",
   "main": "./dist/index.cjs",
@@ -20,12 +23,12 @@
   },
   "peerDependencies": {
     "postgres": "^3.4.0",
-    "@cascaide-ts/core": "0.1.0"
+    "@cascaide-ts/core": "0.5.1"
   },
   "devDependencies": {
     "postgres": "^3.4.0",
     "tsup": "^8.0.0",
-    "@cascaide-ts/core": "0.1.0"
+    "@cascaide-ts/core": "0.5.1"
   },
   "scripts": {
     "build": "tsup",