@jini-ai/core 0.6.22 → 0.6.23

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.6.23
+
+- Security hardening.
+
 # @jini-ai/core
 
 ## 0.6.22

package/dist/approval.d.ts

@@ -35,6 +35,17 @@ export interface RememberedApprovalPort {
         confirmer: HumanConfirmer;
     }): Promise<void>;
 }
+/** Host-owned view/version snapshot captured before asking, then carried into the approved
+ * effect. The host validates it at the effect boundary; this port grants no authorization. */
+export interface ApprovalContextPort {
+    capture(required: {
+        ctx: ToolExecutionContext;
+    }): Promise<unknown>;
+    prepare(required: {
+        ctx: ToolExecutionContext;
+        snapshot: unknown;
+    }): ToolExecutionContext;
+}
 export interface ApprovalSteps<TPrepared, TDescription> {
     prepare(required: {
         ctx: ToolExecutionContext;
@@ -153,7 +164,10 @@ export declare function createApprovalProposalStore<TDescription>({ responseTool
 };
 /** Apply a host classification through the same handler owner used by domain plans.
  * A host description's string `rememberKey` opts into reusable grants; descriptions remain opaque.
+ * Optional context is captured only for asking actions and prepared only after approval.
  * @returns The registration with one approval handler; authorization policy is preserved.
+ * @complexity O(input bytes) snapshot plus bounded injected ports; no retained cross-call state.
+ * @overallScore 100
  */
 export declare function applyApprovalPolicy<TDescription>({ registration, classify, asks, describe, askHuman, notConfirmed }: {
     registration: ToolRegistration;
@@ -171,5 +185,6 @@ export declare function applyApprovalPolicy<TDescription>({ registration, classi
     notConfirmed: ApprovalSteps<string, TDescription>['notConfirmed'];
 }, optional?: {
     remembered?: RememberedApprovalPort;
+    context?: ApprovalContextPort;
 }): ToolRegistration;
 //# sourceMappingURL=approval.d.ts.map

package/dist/approval.js

@@ -249,20 +249,34 @@ export function createApprovalProposalStore({ responseTool, messages }, { create
 }
 /** Apply a host classification through the same handler owner used by domain plans.
  * A host description's string `rememberKey` opts into reusable grants; descriptions remain opaque.
+ * Optional context is captured only for asking actions and prepared only after approval.
  * @returns The registration with one approval handler; authorization policy is preserved.
+ * @complexity O(input bytes) snapshot plus bounded injected ports; no retained cross-call state.
+ * @overallScore 100
  */
 export function applyApprovalPolicy({ registration, classify, asks, describe, askHuman, notConfirmed }, optional = {}) {
     return { ...registration, handler: createApprovalHandler({
-            prepare: async ({ ctx }) => classify({ input: ctx.input }),
+            prepare: async ({ ctx }) => {
+                const actionClass = classify({ input: ctx.input });
+                const ask = asks({ class: actionClass });
+                if (!ask || !optional.context)
+                    return { actionClass, ask };
+                return { actionClass, ask, snapshot: await optional.context.capture({ ctx }) };
+            },
             describe: async ({ ctx, prepared }) => {
-                const ask = asks({ class: prepared });
-                const description = await describe({ ctx, class: prepared });
+                const description = await describe({ ctx, class: prepared.actionClass });
                 const candidate = { value: description };
-                return { ask, description, ...(isNonArrayRecord(candidate) && typeof candidate.value.rememberKey === 'string'
+                return { ask: prepared.ask, description, ...(isNonArrayRecord(candidate) && typeof candidate.value.rememberKey === 'string'
                         ? { rememberKey: candidate.value.rememberKey } : {}) };
             },
-            askHuman, notConfirmed,
-            run: ({ ctx }, options) => registration.handler(ctx, options),
+            askHuman,
+            notConfirmed: ({ reason, prepared }) => notConfirmed({ reason, prepared: prepared?.actionClass }),
+            run: ({ ctx, prepared }, options) => {
+                if (!prepared.ask || !optional.context)
+                    return registration.handler(ctx, options);
+                const executionContext = optional.context.prepare({ ctx, snapshot: prepared.snapshot });
+                return registration.handler(executionContext, options);
+            },
         }, optional) };
 }
 //# sourceMappingURL=approval.js.map

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export type { PackDisposalFailure } from './pack-lifecycle.js';
 export { disposePacks, registerPackTools } from './pack-lifecycle.js';
 export * from './redact.js';
 export * from './user-facing-error.js';
+export { onTeardown, runTeardownSteps, type TeardownHost, type TeardownStep } from './teardown.js';
 export * from './api-token-auth.js';
 export * from './origin-validation.js';
 export * from './principal.js';

package/dist/index.js

@@ -6,6 +6,7 @@ export { createDaemon } from './daemon.js';
 export { disposePacks, registerPackTools } from './pack-lifecycle.js';
 export * from './redact.js';
 export * from './user-facing-error.js';
+export { onTeardown, runTeardownSteps } from './teardown.js';
 export * from './api-token-auth.js';
 export * from './origin-validation.js';
 export * from './principal.js';

package/dist/teardown.d.ts

@@ -0,0 +1,30 @@
+/** A cleanup step may be synchronous or asynchronous; failures are reported after all steps run. */
+export type TeardownStep = () => unknown;
+/** Injected lifecycle registration; core has no dependency on a particular test runner or host. */
+export interface TeardownHost {
+    after(fn: () => unknown): void;
+}
+/**
+ * Attempt every step in reverse registration order. Preserve a single failure's identity;
+ * report several as an AggregateError only after attempting the remaining cleanup.
+ * @param requiredArgs Steps owned by one lifecycle context; the input array is not mutated.
+ * @returns Resolves after cleanup, or rejects with the collected failure(s).
+ * @complexity O(n) time and space for n registered steps, excluding each step's own work.
+ * @example await runTeardownSteps({ steps: [closeDatabase, closeServer] });
+ */
+export declare function runTeardownSteps({ steps }: {
+    steps: readonly TeardownStep[];
+}, _options?: {}): Promise<void>;
+/**
+ * Queue a step on the host's single cleanup hook. Hosts that stop at the first throwing hook
+ * still attempt every registered resource cleanup before this hook reports a failure.
+ * @param requiredArgs Lifecycle host and a step to run when that host finishes.
+ * @returns Nothing; registers one hook on first use, then appends to that host's queue.
+ * @complexity O(1) registration; cleanup is O(n) time/space for n registered steps.
+ * @example onTeardown({ t: context, step: closeServer });
+ */
+export declare function onTeardown({ t, step }: {
+    t: TeardownHost;
+    step: TeardownStep;
+}, _options?: {}): void;
+//# sourceMappingURL=teardown.d.ts.map

package/dist/teardown.js

@@ -0,0 +1,43 @@
+const queues = new WeakMap();
+/**
+ * Attempt every step in reverse registration order. Preserve a single failure's identity;
+ * report several as an AggregateError only after attempting the remaining cleanup.
+ * @param requiredArgs Steps owned by one lifecycle context; the input array is not mutated.
+ * @returns Resolves after cleanup, or rejects with the collected failure(s).
+ * @complexity O(n) time and space for n registered steps, excluding each step's own work.
+ * @example await runTeardownSteps({ steps: [closeDatabase, closeServer] });
+ */
+export async function runTeardownSteps({ steps }, _options = {}) {
+    const failures = [];
+    for (const step of [...steps].reverse()) {
+        try {
+            await step();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length === 1)
+        throw failures[0];
+    if (failures.length > 1)
+        throw new AggregateError(failures, "test teardown failed", { cause: failures[0] });
+}
+/**
+ * Queue a step on the host's single cleanup hook. Hosts that stop at the first throwing hook
+ * still attempt every registered resource cleanup before this hook reports a failure.
+ * @param requiredArgs Lifecycle host and a step to run when that host finishes.
+ * @returns Nothing; registers one hook on first use, then appends to that host's queue.
+ * @complexity O(1) registration; cleanup is O(n) time/space for n registered steps.
+ * @example onTeardown({ t: context, step: closeServer });
+ */
+export function onTeardown({ t, step }, _options = {}) {
+    const queued = queues.get(t);
+    if (queued) {
+        queued.push(step);
+        return;
+    }
+    const steps = [step];
+    queues.set(t, steps);
+    t.after(() => runTeardownSteps({ steps }));
+}
+//# sourceMappingURL=teardown.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/core",
-  "version": "0.6.22",
+  "version": "0.6.23",
   "description": "The Jini kernel: typed DI tokens, pack composition and lifecycle, the tool registry, redaction, and origin/API-token auth primitives. Zero dependencies.",
   "license": "Apache-2.0",
   "repository": {