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

package/dist/cjs/HttpPost.d.ts

@@ -0,0 +1,130 @@
+/**
+ * HTTP POST 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 http-post flow.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "http-post";
+/**
+ * Model-facing description of the http-post flow.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const description = "Post a text body to an absolute URL and return the response; this is irreversible because the remote side may already have acted.";
+/**
+ * Input schema for the http-post flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly body: Schema.String;
+    readonly contentType: Schema.optional<Schema.String>;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly timeout: Schema.optional<Schema.Number>;
+}>;
+/**
+ * Decoded input accepted by the `http-post` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output schema for the http-post 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 `http-post` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Static effect envelope for the http-post flow.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the http-post effect envelope for one decoded input.
+ *
+ * Network reach is expressed as a capability rather than a path envelope, so
+ * a post 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 http-post flow.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * Declaration-only http-post flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    readonly name: "http-post";
+    readonly description: "Post a text body to an absolute URL and return the response; this is irreversible because the remote side may already have acted.";
+    readonly input: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly body: Schema.String;
+        readonly contentType: Schema.optional<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;
+};
+/**
+ * Posts a body through the permission-aware kernel HTTP client.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly body: string;
+    readonly url: string;
+    readonly timeout?: number | undefined;
+    readonly contentType?: string | 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("@smthrs/kernel/HttpClient").HttpClient>;
+//# sourceMappingURL=HttpPost.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HttpPost.d.ts","sourceRoot":"","sources":["../../src/HttpPost.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,cAAc,CAAA;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,WAAW,sIAC6G,CAAA;AAErI;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;EAYhB,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;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAA8E,CAAA;AAElG;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,OAAO,KAAK,CAAC,IAAI,+CAAY,CAAA;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAgC,CAAA;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;GAKG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;qIAKf,CAAA"}

package/dist/cjs/HttpPost.js

@@ -0,0 +1,72 @@
+"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 HttpPost_exports = {};
+__export(HttpPost_exports, {
+  Input: () => Input,
+  Output: () => Output,
+  capabilities: () => capabilities,
+  description: () => description,
+  effects: () => effects,
+  effectsFor: () => effectsFor,
+  flow: () => flow,
+  name: () => name,
+  run: () => run
+});
+module.exports = __toCommonJS(HttpPost_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var HttpClientRequest = __toESM(require("effect/unstable/http/HttpClientRequest"), 1);
+var import_Declaration = require("./internal/Declaration.js");
+var import_Http = require("./internal/Http.js");
+const name = "http-post";
+const description = "Post a text body to an absolute URL and return the response; this is irreversible because the remote side may already have acted.";
+const Input = Schema.Struct({
+  url: Schema.String.annotate({ description: "Absolute http or https URL to post to" }),
+  body: Schema.String.annotate({ description: "Request body sent verbatim" }),
+  contentType: Schema.optional(Schema.String).annotate({
+    description: "Request content type; defaults to application/json"
+  }),
+  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: "irreversible", mode: "expected", reads: [], writes: [] });
+const effectsFor = (_input) => effects;
+const capabilities = [(0, import_Declaration.capability)("net:post", "*")];
+const flow = { name, description, input: Input, output: Output, capabilities, effects };
+const run = Effect.fn("HttpPost.run")(
+  (input) => (0, import_Http.execute)(input, (url) => HttpClientRequest.post(url).pipe(
+    HttpClientRequest.bodyText(input.body, input.contentType ?? "application/json")
+  ))
+);
+//# sourceMappingURL=HttpPost.js.map

package/dist/cjs/HttpPost.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/HttpPost.ts"],
+  "sourcesContent": ["/**\n * HTTP POST flow declaration and portable handler.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as HttpClientRequest from \"effect/unstable/http/HttpClientRequest\"\nimport { capability, envelope } from \"./internal/Declaration.ts\"\nimport { execute, Response, Timeout } from \"./internal/Http.ts\"\n\n/**\n * Registry name for the http-post flow.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"http-post\"\n\n/**\n * Model-facing description of the http-post flow.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description =\n  \"Post a text body to an absolute URL and return the response; this is irreversible because the remote side may already have acted.\"\n\n/**\n * Input schema for the http-post 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 post to\" }),\n  body: Schema.String.annotate({ description: \"Request body sent verbatim\" }),\n  contentType: Schema.optional(Schema.String).annotate({\n    description: \"Request content type; defaults to application/json\"\n  }),\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 `http-post` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * Output schema for the http-post flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Response\n\n/**\n * Decoded output returned by the `http-post` 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 http-post flow.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({ tier: \"irreversible\", mode: \"expected\", reads: [], writes: [] })\n\n/**\n * Narrows the http-post effect envelope for one decoded input.\n *\n * Network reach is expressed as a capability rather than a path envelope, so\n * a post 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 http-post flow.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities = [capability(\"net:post\", \"*\")]\n\n/**\n * Declaration-only http-post 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 * Posts a body through the permission-aware kernel HTTP client.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"HttpPost.run\")((input: Input) =>\n  execute(input, (url) =>\n    HttpClientRequest.post(url).pipe(\n      HttpClientRequest.bodyText(input.body, input.contentType ?? \"application/json\")\n    ))\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AACxB,aAAwB;AACxB,wBAAmC;AACnC,yBAAqC;AACrC,kBAA2C;AAQpC,MAAM,OAAO;AAQb,MAAM,cACX;AAQK,MAAM,QAAQ,OAAO,OAAO;AAAA,EACjC,KAAK,OAAO,OAAO,SAAS,EAAE,aAAa,wCAAwC,CAAC;AAAA,EACpF,MAAM,OAAO,OAAO,SAAS,EAAE,aAAa,6BAA6B,CAAC;AAAA,EAC1E,aAAa,OAAO,SAAS,OAAO,MAAM,EAAE,SAAS;AAAA,IACnD,aAAa;AAAA,EACf,CAAC;AAAA,EACD,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;AAgBf,MAAM,cAAU,6BAAS,EAAE,MAAM,gBAAgB,MAAM,YAAY,OAAO,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;AAW1F,MAAM,aAAa,CAAC,WAA8B;AAQlD,MAAM,eAAe,KAAC,+BAAW,YAAY,GAAG,CAAC;AAQjD,MAAM,OAAO,EAAE,MAAM,aAAa,OAAO,OAAO,QAAQ,QAAQ,cAAc,QAAQ;AAQtF,MAAM,MAAM,OAAO,GAAG,cAAc;AAAA,EAAE,CAAC,cAC5C,qBAAQ,OAAO,CAAC,QACd,kBAAkB,KAAK,GAAG,EAAE;AAAA,IAC1B,kBAAkB,SAAS,MAAM,MAAM,MAAM,eAAe,kBAAkB;AAAA,EAChF,CAAC;AACL;",
+  "names": []
+}

package/dist/cjs/LanguageServer.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The code-intelligence seam behind the `lsp` flow.
+ *
+ * A host binds {@link LanguageServer} to a client such as
+ * `NodeLanguageServer.layer`. Every method answers one language-server request
+ * with the server's own result; {@link layerNoop} answers every request with
+ * `unsupported`, for a host that runs no server.
+ *
+ * @since 1.0.0
+ */
+import { Context, Effect, Layer } from "effect";
+import * as StdError from "./StdError.ts";
+/**
+ * A point in a file, addressed the way a language server addresses it.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Position {
+    readonly path: string;
+    readonly line: number;
+    readonly character: number;
+}
+/**
+ * The code-intelligence seam. Every method answers one language-server
+ * request and reports an unavailable server as a typed failure.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface LanguageServer {
+    readonly hover: (position: Position) => Effect.Effect<unknown, StdError.StdError>;
+    readonly definition: (position: Position) => Effect.Effect<unknown, StdError.StdError>;
+    readonly references: (position: Position) => Effect.Effect<unknown, StdError.StdError>;
+    readonly implementation: (position: Position) => Effect.Effect<unknown, StdError.StdError>;
+    readonly documentSymbols: (path: string) => Effect.Effect<unknown, StdError.StdError>;
+    readonly workspaceSymbols: (query: string) => Effect.Effect<unknown, StdError.StdError>;
+    readonly prepareCallHierarchy: (position: Position) => Effect.Effect<unknown, StdError.StdError>;
+    readonly callHierarchyIncoming: (position: Position) => Effect.Effect<unknown, StdError.StdError>;
+    readonly callHierarchyOutgoing: (position: Position) => Effect.Effect<unknown, StdError.StdError>;
+    /**
+     * The file's diagnostics as a document report, `{ kind: "full", items }`.
+     * A server without pull diagnostics answers with what it last published for
+     * the latest synced text.
+     */
+    readonly diagnostics: (path: string) => Effect.Effect<unknown, StdError.StdError>;
+    /**
+     * Tells the server a file now holds `text`: opens it on first sync and sends
+     * the full new text on every later one.
+     */
+    readonly sync: (path: string, text: string) => Effect.Effect<void, StdError.StdError>;
+    /** Tells the server a synced file is gone; a file never synced is a no-op. */
+    readonly close: (path: string) => Effect.Effect<void, StdError.StdError>;
+    /**
+     * Re-reads every synced file from disk: sends the text of each that changed
+     * and closes each that is gone, so a file something else changed is not
+     * left stale on the server.
+     */
+    readonly refresh: Effect.Effect<void, StdError.StdError>;
+}
+/**
+ * The {@link LanguageServer} service tag.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export declare const LanguageServer: Context.Service<LanguageServer, LanguageServer>;
+/**
+ * Builds a {@link LanguageServer} from an implementation of its methods.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (service: LanguageServer) => LanguageServer;
+/**
+ * A {@link LanguageServer} that reports `unsupported` for every request,
+ * for an environment with no server configured.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const makeNoop: () => LanguageServer;
+/**
+ * Provides {@link makeNoop}.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layerNoop: Layer.Layer<LanguageServer>;
+//# sourceMappingURL=LanguageServer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LanguageServer.d.ts","sourceRoot":"","sources":["../../src/LanguageServer.ts"],"names":[],"mappings":"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"}

package/dist/cjs/LanguageServer.js

@@ -0,0 +1,60 @@
+"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 name in all)
+    __defProp(target, name, { get: all[name], 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 LanguageServer_exports = {};
+__export(LanguageServer_exports, {
+  LanguageServer: () => LanguageServer,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeNoop: () => makeNoop
+});
+module.exports = __toCommonJS(LanguageServer_exports);
+var import_effect = require("effect");
+var StdError = __toESM(require("./StdError.js"), 1);
+const LanguageServer = import_effect.Context.Service(
+  "@smthrs/std/LanguageServer"
+);
+const make = (service) => LanguageServer.of(service);
+const unsupported = () => import_effect.Effect.fail(new StdError.StdError({ code: "unsupported", message: "Language server support is unavailable" }));
+const makeNoop = () => make({
+  hover: unsupported,
+  definition: unsupported,
+  references: unsupported,
+  implementation: unsupported,
+  documentSymbols: unsupported,
+  workspaceSymbols: unsupported,
+  prepareCallHierarchy: unsupported,
+  callHierarchyIncoming: unsupported,
+  callHierarchyOutgoing: unsupported,
+  diagnostics: unsupported,
+  sync: unsupported,
+  close: unsupported,
+  refresh: unsupported()
+});
+const layerNoop = import_effect.Layer.succeed(LanguageServer, makeNoop());
+//# sourceMappingURL=LanguageServer.js.map

package/dist/cjs/LanguageServer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/LanguageServer.ts"],
+  "sourcesContent": ["/**\n * The code-intelligence seam behind the `lsp` flow.\n *\n * A host binds {@link LanguageServer} to a client such as\n * `NodeLanguageServer.layer`. Every method answers one language-server request\n * with the server's own result; {@link layerNoop} answers every request with\n * `unsupported`, for a host that runs no server.\n *\n * @since 1.0.0\n */\n\nimport { Context, Effect, Layer } from \"effect\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * A point in a file, addressed the way a language server addresses it.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Position {\n  readonly path: string\n  readonly line: number\n  readonly character: number\n}\n/**\n * The code-intelligence seam. Every method answers one language-server\n * request and reports an unavailable server as a typed failure.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface LanguageServer {\n  readonly hover: (position: Position) => Effect.Effect<unknown, StdError.StdError>\n  readonly definition: (position: Position) => Effect.Effect<unknown, StdError.StdError>\n  readonly references: (position: Position) => Effect.Effect<unknown, StdError.StdError>\n  readonly implementation: (position: Position) => Effect.Effect<unknown, StdError.StdError>\n  readonly documentSymbols: (path: string) => Effect.Effect<unknown, StdError.StdError>\n  readonly workspaceSymbols: (query: string) => Effect.Effect<unknown, StdError.StdError>\n  readonly prepareCallHierarchy: (position: Position) => Effect.Effect<unknown, StdError.StdError>\n  readonly callHierarchyIncoming: (position: Position) => Effect.Effect<unknown, StdError.StdError>\n  readonly callHierarchyOutgoing: (position: Position) => Effect.Effect<unknown, StdError.StdError>\n  /**\n   * The file's diagnostics as a document report, `{ kind: \"full\", items }`.\n   * A server without pull diagnostics answers with what it last published for\n   * the latest synced text.\n   */\n  readonly diagnostics: (path: string) => Effect.Effect<unknown, StdError.StdError>\n  /**\n   * Tells the server a file now holds `text`: opens it on first sync and sends\n   * the full new text on every later one.\n   */\n  readonly sync: (path: string, text: string) => Effect.Effect<void, StdError.StdError>\n  /** Tells the server a synced file is gone; a file never synced is a no-op. */\n  readonly close: (path: string) => Effect.Effect<void, StdError.StdError>\n  /**\n   * Re-reads every synced file from disk: sends the text of each that changed\n   * and closes each that is gone, so a file something else changed is not\n   * left stale on the server.\n   */\n  readonly refresh: Effect.Effect<void, StdError.StdError>\n}\n/**\n * The {@link LanguageServer} service tag.\n *\n * @category services\n * @since 1.0.0\n */\nexport const LanguageServer: Context.Service<LanguageServer, LanguageServer> = Context.Service(\n  \"@smthrs/std/LanguageServer\"\n)\n/**\n * Builds a {@link LanguageServer} from an implementation of its methods.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (service: LanguageServer): LanguageServer => LanguageServer.of(service)\nconst unsupported = (): Effect.Effect<never, StdError.StdError> =>\n  Effect.fail(new StdError.StdError({ code: \"unsupported\", message: \"Language server support is unavailable\" }))\n/**\n * A {@link LanguageServer} that reports `unsupported` for every request,\n * for an environment with no server configured.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const makeNoop = (): LanguageServer =>\n  make({\n    hover: unsupported,\n    definition: unsupported,\n    references: unsupported,\n    implementation: unsupported,\n    documentSymbols: unsupported,\n    workspaceSymbols: unsupported,\n    prepareCallHierarchy: unsupported,\n    callHierarchyIncoming: unsupported,\n    callHierarchyOutgoing: unsupported,\n    diagnostics: unsupported,\n    sync: unsupported,\n    close: unsupported,\n    refresh: unsupported()\n  })\n/**\n * Provides {@link makeNoop}.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerNoop: Layer.Layer<LanguageServer> = Layer.succeed(LanguageServer, makeNoop())\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,oBAAuC;AACvC,eAA0B;AAwDnB,MAAM,iBAAkE,sBAAQ;AAAA,EACrF;AACF;AAOO,MAAM,OAAO,CAAC,YAA4C,eAAe,GAAG,OAAO;AAC1F,MAAM,cAAc,MAClB,qBAAO,KAAK,IAAI,SAAS,SAAS,EAAE,MAAM,eAAe,SAAS,yCAAyC,CAAC,CAAC;AAQxG,MAAM,WAAW,MACtB,KAAK;AAAA,EACH,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,kBAAkB;AAAA,EAClB,sBAAsB;AAAA,EACtB,uBAAuB;AAAA,EACvB,uBAAuB;AAAA,EACvB,aAAa;AAAA,EACb,MAAM;AAAA,EACN,OAAO;AAAA,EACP,SAAS,YAAY;AACvB,CAAC;AAOI,MAAM,YAAyC,oBAAM,QAAQ,gBAAgB,SAAS,CAAC;",
+  "names": []
+}

package/dist/cjs/Ls.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Directory listing flow declaration and portable handler.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Schema from "effect/Schema";
+import * as StdError from "./StdError.ts";
+/**
+ * The registry name of the `ls` flow.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "ls";
+/**
+ * The one-line description the model sees for the `ls` flow.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const 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.";
+/**
+ * What the `ls` flow accepts.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly offset: Schema.optional<Schema.Int>;
+    readonly limit: Schema.optional<Schema.Int>;
+}>;
+/**
+ * Decoded input accepted by the `ls` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * What the `ls` flow returns.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const 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>;
+}>;
+/**
+ * Decoded output returned by the `ls` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * The declared effect envelope of the `ls` flow, before any input is known.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows {@link effects} to what this particular input actually touches.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (input: typeof Input.Type) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * The authority the `ls` flow requires.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * The `ls` flow declaration: schemas, capabilities, and effects, with the
+ * implementation attached separately.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    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;
+};
+/**
+ * What a call to this flow does, for a reader of a run.
+ *
+ * Display metadata only. `@smthrs/registry` `Descriptor.FlowActivity` is the
+ * governing vocabulary and `StandardFlows` binds this value onto the flow's
+ * descriptor, where the binding site checks it. `declarationDigest` excludes
+ * it, so declaring it cannot invalidate a call identity or a cached prompt.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const activity: "reads";
+/**
+ * How one recorded call to this flow reads: the verb for each settlement, the
+ * input field that is its subject, and the measured output fields a one-line
+ * summary may count.
+ *
+ * Display metadata only, governed by `@smthrs/registry`
+ * `Descriptor.CallPresentation` and checked where `StandardFlows` binds it.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const presentation: {
+    readonly verb: {
+        readonly pending: "listing";
+        readonly success: "listed";
+        readonly failure: "failed to list";
+    };
+    readonly subject: "path";
+    readonly result: "entries";
+};
+/**
+ * Lists a directory deterministically. A file supplied as `path` is reported
+ * as `not_a_directory`.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly path: string;
+    readonly limit?: number | undefined;
+    readonly offset?: number | undefined;
+}) => Effect.Effect<{
+    readonly entries: readonly {
+        readonly name: string;
+        readonly kind: "directory" | "file";
+    }[];
+    readonly truncated: boolean;
+    readonly total: number;
+    readonly notice?: string | undefined;
+}, StdError.StdError, import("effect/Path").Path | FileSystem.FileSystem>;
+//# sourceMappingURL=Ls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ls.d.ts","sourceRoot":"","sources":["../../src/Ls.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,OAAO,CAAA;AAExB;;;;;GAKG;AACH,eAAO,MAAM,WAAW,gKACuI,CAAA;AAE/J;;;;;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;;;;;;;;EAQjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAA6E,CAAA;AAEjG;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAK,CAAC,IAAI,+CAC8B,CAAA;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAiC,CAAA;AAE1D;;;;;;GAMG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAG,OAAgB,CAAA;AAExC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAIf,CAAA;AAMV;;;;;;GAMG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;yEAwEd,CAAA"}