@smthrs/std 0.0.0-stage → 1.0.0-rc.12

package/dist/cjs/Explore.d.ts

@@ -0,0 +1,328 @@
+/**
+ * Read-only workspace reconnaissance as a dynamic flow.
+ *
+ * @since 1.0.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Registry name for the explore flow.
+ *
+ * @category metadata
+ * @since 1.0.0
+ */
+export declare const name: "explore";
+/**
+ * Model-facing description of the explore flow.
+ *
+ * @category metadata
+ * @since 1.0.0
+ */
+export declare const description = "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+/**
+ * Input accepted by the explore flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly prompt: Schema.String;
+}>;
+/**
+ * Decoded input accepted by the `explore` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output returned by the explore flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Output: Schema.Struct<{
+    readonly findings: Schema.String;
+}>;
+/**
+ * Decoded output returned by the `explore` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Static effect envelope for read-only workspace reconnaissance.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the explore effect declaration for one decoded input.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (_input: typeof Input.Type) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Transitive capabilities of the read-only flows available to explore.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: ReadonlyArray<string>;
+/**
+ * Constructs an explore flow, optionally pinned to a model.
+ *
+ * Model selection remains optional so the invoking seat can inject its model.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (options: {
+    readonly model?: string | undefined;
+}) => {
+    readonly name: "explore";
+    readonly description: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly input: Schema.Struct<{
+        readonly prompt: Schema.String;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly findings: Schema.String;
+    }>;
+    readonly model: string | undefined;
+    readonly flows: readonly [{
+        readonly name: "read";
+        readonly description: "Read a text file by 1-based offset and limit. content is RAW file text with no line-number prefixes, so any line of it is an edit anchor as it stands; the numbers are startLine/endLine.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly content: Schema.String;
+            readonly startLine: Schema.Number;
+            readonly endLine: Schema.Number;
+            readonly totalLines: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "ls";
+        readonly description: "List a directory with directories first, trailing /, and locale-independent UTF-16 code-unit ordering; use 1-based offset and limit to page large listings.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+            }>>;
+            readonly total: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "glob";
+        readonly description: "Find files through the Smithers Ripgrep Subset v1 contract.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.NonEmptyString;
+            readonly root: Schema.optional<Schema.String>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly paths: Schema.$Array<Schema.String>;
+            readonly total: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "grep";
+        readonly description: "Search file contents through the Smithers Ripgrep Subset v1 contract. limit counts matches, each carrying its own context and enclosing definition; fixedStrings searches a literal, and one is retried.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.String;
+            readonly root: Schema.optional<Schema.String>;
+            readonly fixedStrings: Schema.optional<Schema.Boolean>;
+            readonly ignoreCase: Schema.optional<Schema.Boolean>;
+            readonly smartCase: Schema.optional<Schema.Boolean>;
+            readonly globs: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly beforeContext: Schema.optional<Schema.Int>;
+            readonly afterContext: Schema.optional<Schema.Int>;
+            readonly context: Schema.optional<Schema.Int>;
+            readonly maxCount: Schema.optional<Schema.Int>;
+            readonly filesWithMatches: Schema.optional<Schema.Boolean>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly symbols: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly matches: Schema.$Array<Schema.Struct<{
+                readonly file: Schema.String;
+                readonly line: Schema.Int;
+                readonly text: Schema.String;
+                readonly before: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly after: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly symbol: Schema.optional<Schema.Struct<{
+                    readonly kind: Schema.String;
+                    readonly name: Schema.String;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>>;
+            }>>;
+            readonly files: Schema.$Array<Schema.String>;
+            readonly filesSearched: Schema.Int;
+            readonly skippedBinary: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly retriedAsLiteral: Schema.optional<Schema.Boolean>;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }];
+    readonly prompt: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly capabilities: readonly string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+/**
+ * Default explore declaration with seat-selected model injection.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    readonly name: "explore";
+    readonly description: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly input: Schema.Struct<{
+        readonly prompt: Schema.String;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly findings: Schema.String;
+    }>;
+    readonly model: string | undefined;
+    readonly flows: readonly [{
+        readonly name: "read";
+        readonly description: "Read a text file by 1-based offset and limit. content is RAW file text with no line-number prefixes, so any line of it is an edit anchor as it stands; the numbers are startLine/endLine.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly content: Schema.String;
+            readonly startLine: Schema.Number;
+            readonly endLine: Schema.Number;
+            readonly totalLines: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "ls";
+        readonly description: "List a directory with directories first, trailing /, and locale-independent UTF-16 code-unit ordering; use 1-based offset and limit to page large listings.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+            }>>;
+            readonly total: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "glob";
+        readonly description: "Find files through the Smithers Ripgrep Subset v1 contract.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.NonEmptyString;
+            readonly root: Schema.optional<Schema.String>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly paths: Schema.$Array<Schema.String>;
+            readonly total: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "grep";
+        readonly description: "Search file contents through the Smithers Ripgrep Subset v1 contract. limit counts matches, each carrying its own context and enclosing definition; fixedStrings searches a literal, and one is retried.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.String;
+            readonly root: Schema.optional<Schema.String>;
+            readonly fixedStrings: Schema.optional<Schema.Boolean>;
+            readonly ignoreCase: Schema.optional<Schema.Boolean>;
+            readonly smartCase: Schema.optional<Schema.Boolean>;
+            readonly globs: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly beforeContext: Schema.optional<Schema.Int>;
+            readonly afterContext: Schema.optional<Schema.Int>;
+            readonly context: Schema.optional<Schema.Int>;
+            readonly maxCount: Schema.optional<Schema.Int>;
+            readonly filesWithMatches: Schema.optional<Schema.Boolean>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly symbols: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly matches: Schema.$Array<Schema.Struct<{
+                readonly file: Schema.String;
+                readonly line: Schema.Int;
+                readonly text: Schema.String;
+                readonly before: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly after: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly symbol: Schema.optional<Schema.Struct<{
+                    readonly kind: Schema.String;
+                    readonly name: Schema.String;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>>;
+            }>>;
+            readonly files: Schema.$Array<Schema.String>;
+            readonly filesSearched: Schema.Int;
+            readonly skippedBinary: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly retriedAsLiteral: Schema.optional<Schema.Boolean>;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }];
+    readonly prompt: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly capabilities: readonly string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+//# sourceMappingURL=Explore.d.ts.map

package/dist/cjs/Explore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Explore.d.ts","sourceRoot":"","sources":["../../src/Explore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAOvC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAG,SAAkB,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,WAAW,yHACgG,CAAA;AAExH;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;EAIhB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;EAIjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAKlB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,OAAO,KAAK,CAAC,IAAI,+CAAY,CAAA;AAWhE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,aAAa,CAAC,MAAM,CAE9C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUU,CAAA;AAEX;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAW,CAAA"}

package/dist/cjs/Explore.js

@@ -0,0 +1,90 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Explore_exports = {};
+__export(Explore_exports, {
+  Input: () => Input,
+  Output: () => Output,
+  capabilities: () => capabilities,
+  description: () => description,
+  effects: () => effects,
+  effectsFor: () => effectsFor,
+  flow: () => flow,
+  make: () => make,
+  name: () => name
+});
+module.exports = __toCommonJS(Explore_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Glob = __toESM(require("./Glob.js"), 1);
+var Grep = __toESM(require("./Grep.js"), 1);
+var import_Declaration = require("./internal/Declaration.js");
+var Ls = __toESM(require("./Ls.js"), 1);
+var Read = __toESM(require("./Read.js"), 1);
+const name = "explore";
+const description = "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+const Input = Schema.Struct({
+  prompt: Schema.String.annotate({
+    description: "The workspace question to investigate."
+  })
+});
+const Output = Schema.Struct({
+  findings: Schema.String.annotate({
+    description: "Evidence-backed findings with file:line citations."
+  })
+});
+const effects = (0, import_Declaration.envelope)({
+  tier: "sealed",
+  mode: "hermetic",
+  reads: ["/**"],
+  writes: []
+});
+const effectsFor = (_input) => effects;
+const flows = Object.freeze(
+  [
+    Read.flow,
+    Ls.flow,
+    Glob.flow,
+    Grep.flow
+  ]
+);
+const capabilities = Object.freeze(
+  [...new Set(flows.flatMap((flow2) => flow2.capabilities))].sort()
+);
+const make = (options) => ({
+  name,
+  description,
+  input: Input,
+  output: Output,
+  model: options.model,
+  flows,
+  prompt: description,
+  capabilities,
+  effects
+});
+const flow = make({});
+//# sourceMappingURL=Explore.js.map

package/dist/cjs/Explore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Explore.ts"],
+  "sourcesContent": ["/**\n * Read-only workspace reconnaissance as a dynamic flow.\n *\n * @since 1.0.0\n */\n\nimport * as Schema from \"effect/Schema\"\nimport * as Glob from \"./Glob.ts\"\nimport * as Grep from \"./Grep.ts\"\nimport { envelope } from \"./internal/Declaration.ts\"\nimport * as Ls from \"./Ls.ts\"\nimport * as Read from \"./Read.ts\"\n\n/**\n * Registry name for the explore flow.\n *\n * @category metadata\n * @since 1.0.0\n */\nexport const name = \"explore\" as const\n\n/**\n * Model-facing description of the explore flow.\n *\n * @category metadata\n * @since 1.0.0\n */\nexport const description =\n  \"Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.\"\n\n/**\n * Input accepted by the explore flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  prompt: Schema.String.annotate({\n    description: \"The workspace question to investigate.\"\n  })\n})\n\n/**\n * Decoded input accepted by the `explore` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * Output returned by the explore flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Schema.Struct({\n  findings: Schema.String.annotate({\n    description: \"Evidence-backed findings with file:line citations.\"\n  })\n})\n\n/**\n * Decoded output returned by the `explore` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n\n/**\n * Static effect envelope for read-only workspace reconnaissance.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({\n  tier: \"sealed\",\n  mode: \"hermetic\",\n  reads: [\"/**\"],\n  writes: []\n})\n\n/**\n * Narrows the explore effect declaration for one decoded input.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (_input: typeof Input.Type) => effects\n\nconst flows = Object.freeze(\n  [\n    Read.flow,\n    Ls.flow,\n    Glob.flow,\n    Grep.flow\n  ] as const\n)\n\n/**\n * Transitive capabilities of the read-only flows available to explore.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities: ReadonlyArray<string> = Object.freeze(\n  [...new Set(flows.flatMap((flow) => flow.capabilities))].sort()\n)\n\n/**\n * Constructs an explore flow, optionally pinned to a model.\n *\n * Model selection remains optional so the invoking seat can inject its model.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (options: {\n  readonly model?: string | undefined\n}) => ({\n  name,\n  description,\n  input: Input,\n  output: Output,\n  model: options.model,\n  flows,\n  prompt: description,\n  capabilities,\n  effects\n} as const)\n\n/**\n * Default explore declaration with seat-selected model injection.\n *\n * @category flows\n * @since 1.0.0\n */\nexport const flow = make({})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AACxB,WAAsB;AACtB,WAAsB;AACtB,yBAAyB;AACzB,SAAoB;AACpB,WAAsB;AAQf,MAAM,OAAO;AAQb,MAAM,cACX;AAQK,MAAM,QAAQ,OAAO,OAAO;AAAA,EACjC,QAAQ,OAAO,OAAO,SAAS;AAAA,IAC7B,aAAa;AAAA,EACf,CAAC;AACH,CAAC;AAgBM,MAAM,SAAS,OAAO,OAAO;AAAA,EAClC,UAAU,OAAO,OAAO,SAAS;AAAA,IAC/B,aAAa;AAAA,EACf,CAAC;AACH,CAAC;AAgBM,MAAM,cAAU,6BAAS;AAAA,EAC9B,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO,CAAC,KAAK;AAAA,EACb,QAAQ,CAAC;AACX,CAAC;AAQM,MAAM,aAAa,CAAC,WAA8B;AAEzD,MAAM,QAAQ,OAAO;AAAA,EACnB;AAAA,IACE,KAAK;AAAA,IACL,GAAG;AAAA,IACH,KAAK;AAAA,IACL,KAAK;AAAA,EACP;AACF;AAQO,MAAM,eAAsC,OAAO;AAAA,EACxD,CAAC,GAAG,IAAI,IAAI,MAAM,QAAQ,CAACA,UAASA,MAAK,YAAY,CAAC,CAAC,EAAE,KAAK;AAChE;AAUO,MAAM,OAAO,CAAC,aAEd;AAAA,EACL;AAAA,EACA;AAAA,EACA,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,OAAO,QAAQ;AAAA,EACf;AAAA,EACA,QAAQ;AAAA,EACR;AAAA,EACA;AACF;AAQO,MAAM,OAAO,KAAK,CAAC,CAAC;",
+  "names": ["flow"]
+}

package/dist/cjs/Fetch.d.ts

@@ -0,0 +1,130 @@
+/**
+ * HTTP GET flow declaration and portable handler.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+/**
+ * Registry name for the fetch flow.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "fetch";
+/**
+ * Model-facing description of the fetch flow.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const description = "Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.";
+/**
+ * Input schema for the fetch flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly timeout: Schema.optional<Schema.Number>;
+}>;
+/**
+ * Decoded input accepted by the `fetch` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output schema for the fetch flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Output: Schema.Struct<{
+    readonly status: Schema.Number;
+    readonly body: Schema.String;
+    readonly truncated: Schema.Boolean;
+    readonly notice: Schema.optional<Schema.String>;
+}>;
+/**
+ * Decoded output returned by the `fetch` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Static effect envelope for the fetch flow.
+ *
+ * A retrieval leaves no durable state behind, so it is sealed even though it
+ * leaves the machine.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the fetch effect envelope for one decoded input.
+ *
+ * Network reach is expressed as a capability rather than a path envelope, so
+ * a retrieval has nothing left to narrow.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (_input: typeof Input.Type) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Capabilities required by the fetch flow.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * Declaration-only fetch flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    readonly name: "fetch";
+    readonly description: "Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.";
+    readonly input: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly timeout: Schema.optional<Schema.Number>;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly status: Schema.Number;
+        readonly body: Schema.String;
+        readonly truncated: Schema.Boolean;
+        readonly notice: Schema.optional<Schema.String>;
+    }>;
+    readonly capabilities: string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+/**
+ * Retrieves a URL through the permission-aware kernel HTTP client.
+ *
+ * Error statuses are ordinary results; only transport, permission, and body
+ * decoding failures use the typed error channel.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly url: string;
+    readonly timeout?: number | undefined;
+    readonly headers?: {
+        readonly [x: string]: string;
+    } | undefined;
+}) => Effect.Effect<{
+    readonly status: number;
+    readonly body: string;
+    readonly truncated: boolean;
+    readonly notice?: string | undefined;
+}, import("./StdError.ts").StdError, import("@smthrs/kernel/GrantStore").GrantStore | import("effect/http/HttpClient").HttpClient>;
+//# sourceMappingURL=Fetch.d.ts.map

package/dist/cjs/Fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fetch.d.ts","sourceRoot":"","sources":["../../src/Fetch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,UAAU,CAAA;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,WAAW,kIACyG,CAAA;AAEjI;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;EAQhB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;;;EAAW,CAAA;AAE9B;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,4CAAwE,CAAA;AAE5F;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,OAAO,KAAK,CAAC,IAAI,+CAAY,CAAA;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAA+B,CAAA;AAExD;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;kIAAkF,CAAA"}

package/dist/cjs/Fetch.js

@@ -0,0 +1,64 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Fetch_exports = {};
+__export(Fetch_exports, {
+  Input: () => Input,
+  Output: () => Output,
+  capabilities: () => capabilities,
+  description: () => description,
+  effects: () => effects,
+  effectsFor: () => effectsFor,
+  flow: () => flow,
+  name: () => name,
+  run: () => run
+});
+module.exports = __toCommonJS(Fetch_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var HttpClientRequest = __toESM(require("effect/http/HttpClientRequest"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_Declaration = require("./internal/Declaration.js");
+var import_Http = require("./internal/Http.js");
+const name = "fetch";
+const description = "Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.";
+const Input = Schema.Struct({
+  url: Schema.String.annotate({ description: "Absolute http or https URL to retrieve" }),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Additional request headers"
+  }),
+  timeout: Schema.optional(import_Http.Timeout).annotate({
+    description: "Total request and response body timeout in seconds; defaults to 30, capped at 120"
+  })
+});
+const Output = import_Http.Response;
+const effects = (0, import_Declaration.envelope)({ tier: "sealed", mode: "expected", reads: [], writes: [] });
+const effectsFor = (_input) => effects;
+const capabilities = [(0, import_Declaration.capability)("net:get", "*")];
+const flow = { name, description, input: Input, output: Output, capabilities, effects };
+const run = Effect.fn("Fetch.run")((input) => (0, import_Http.execute)(input, HttpClientRequest.get));
+//# sourceMappingURL=Fetch.js.map

package/dist/cjs/Fetch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Fetch.ts"],
+  "sourcesContent": ["/**\n * HTTP GET flow declaration and portable handler.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as HttpClientRequest from \"effect/http/HttpClientRequest\"\nimport * as Schema from \"effect/Schema\"\nimport { capability, envelope } from \"./internal/Declaration.ts\"\nimport { execute, Response, Timeout } from \"./internal/Http.ts\"\n\n/**\n * Registry name for the fetch flow.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"fetch\"\n\n/**\n * Model-facing description of the fetch flow.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description =\n  \"Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.\"\n\n/**\n * Input schema for the fetch flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  url: Schema.String.annotate({ description: \"Absolute http or https URL to retrieve\" }),\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({\n    description: \"Additional request headers\"\n  }),\n  timeout: Schema.optional(Timeout).annotate({\n    description: \"Total request and response body timeout in seconds; defaults to 30, capped at 120\"\n  })\n})\n\n/**\n * Decoded input accepted by the `fetch` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * Output schema for the fetch flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Response\n\n/**\n * Decoded output returned by the `fetch` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n\n/**\n * Static effect envelope for the fetch flow.\n *\n * A retrieval leaves no durable state behind, so it is sealed even though it\n * leaves the machine.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({ tier: \"sealed\", mode: \"expected\", reads: [], writes: [] })\n\n/**\n * Narrows the fetch effect envelope for one decoded input.\n *\n * Network reach is expressed as a capability rather than a path envelope, so\n * a retrieval has nothing left to narrow.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (_input: typeof Input.Type) => effects\n\n/**\n * Capabilities required by the fetch flow.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities = [capability(\"net:get\", \"*\")]\n\n/**\n * Declaration-only fetch flow.\n *\n * @category flows\n * @since 1.0.0\n */\nexport const flow = { name, description, input: Input, output: Output, capabilities, effects } as const\n\n/**\n * Retrieves a URL through the permission-aware kernel HTTP client.\n *\n * Error statuses are ordinary results; only transport, permission, and body\n * decoding failures use the typed error channel.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"Fetch.run\")((input: Input) => execute(input, HttpClientRequest.get))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AACxB,wBAAmC;AACnC,aAAwB;AACxB,yBAAqC;AACrC,kBAA2C;AAQpC,MAAM,OAAO;AAQb,MAAM,cACX;AAQK,MAAM,QAAQ,OAAO,OAAO;AAAA,EACjC,KAAK,OAAO,OAAO,SAAS,EAAE,aAAa,yCAAyC,CAAC;AAAA,EACrF,SAAS,OAAO,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,MAAM,CAAC,EAAE,SAAS;AAAA,IAC7E,aAAa;AAAA,EACf,CAAC;AAAA,EACD,SAAS,OAAO,SAAS,mBAAO,EAAE,SAAS;AAAA,IACzC,aAAa;AAAA,EACf,CAAC;AACH,CAAC;AAgBM,MAAM,SAAS;AAmBf,MAAM,cAAU,6BAAS,EAAE,MAAM,UAAU,MAAM,YAAY,OAAO,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;AAWpF,MAAM,aAAa,CAAC,WAA8B;AAQlD,MAAM,eAAe,KAAC,+BAAW,WAAW,GAAG,CAAC;AAQhD,MAAM,OAAO,EAAE,MAAM,aAAa,OAAO,OAAO,QAAQ,QAAQ,cAAc,QAAQ;AAWtF,MAAM,MAAM,OAAO,GAAG,WAAW,EAAE,CAAC,cAAiB,qBAAQ,OAAO,kBAAkB,GAAG,CAAC;",
+  "names": []
+}