dsh-permission-rules 0.4.2 → 0.5.0

package/lib/types/settings.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Host-side settings-namespace wiring: registers the whole plugin config
+ * as the `permission-rules` settings section (editable from the Web
+ * settings surface, loopback-only), keeps the runtime's config source
+ * pointed at the resolved section, and rebinds the network proxy when a
+ * bind/env-relevant knob changes live. On hosts without a settings
+ * service (the rc.6 line) nothing registers and the composition entry
+ * keeps serving the config — the plugin stays fully functional.
+ *
+ * The registration uses only structural interfaces: `@deepseek-ai/
+ * dsh-settings` is not an rc.6 peer, so importing it would hard-fail
+ * older hosts; the real service satisfies these shapes.
+ * @module dsh-permission-rules/settings
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Config as PluginConfig } from './config.ts';
+import type { PermissionRulesRuntime } from './runtime.ts';
+/** The settings namespace this plugin owns (kebab-case, per the provider contract). */
+export declare const SETTINGS_NAMESPACE = "permission-rules";
+/**
+ * Register the settings section and bind the runtime's live config
+ * source. Runs only where a settings service is composed.
+ * @param ctx - the plugin context.
+ * @param runtime - the runtime whose config source follows the section.
+ * @param entry - the composition entry config (the section's `base` layer).
+ */
+export declare function attachSettingsSection(ctx: Context, runtime: PermissionRulesRuntime, entry: PluginConfig): void;
+//# sourceMappingURL=settings.d.ts.map

package/lib/types/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/settings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,KAAK,EAAE,MAAM,IAAI,YAAY,EAAkB,MAAM,aAAa,CAAA;AACzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,qBAAqB,CAAA;AAkBpD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CA0B9G"}

package/lib/types/typert.host.d.ts

@@ -0,0 +1,166 @@
+/**
+ * The hand-written Typert HOST manifest for `dsh-permission-rules`,
+ * exported as `./typert` so the harness's typert-loader registers the
+ * `permissionRules` settings-page invocations automatically when this
+ * plugin mounts. Same shape as a generator output (validated by the
+ * loader): package face, empty model and schemas, and the canonical
+ * invocation list shared with the client Remote contribution
+ * (`src/wire.ts`).
+ * @module dsh-permission-rules/typert
+ */
+/** Host Typert manifest (validated by `@deepseek-ai/dsh-typert-loader`). */
+export declare const TYPERT: Readonly<{
+    package: "dsh-permission-rules";
+    face: "host";
+    schemas: readonly never[];
+    invocations: readonly (Readonly<{
+        readonly id: "dsh-permission-rules#permissionRules/networkStatus";
+        readonly service: "permissionRules";
+        readonly namespace: "permissionRules";
+        readonly method: "networkStatus";
+        readonly invocation: Readonly<{
+            kind: "direct";
+        }>;
+        readonly parameters: readonly never[];
+        readonly result: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#PermissionRulesSnapshot";
+            schema: import("zod").ZodObject<{
+                enabled: import("zod").ZodBoolean;
+                mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
+                configuredMode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"auto">, import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
+                sandboxMode: import("zod").ZodNullable<import("zod").ZodString>;
+                proxyPort: import("zod").ZodNumber;
+                proxyActive: import("zod").ZodBoolean;
+                denied: import("zod").ZodNumber;
+                askBlocked: import("zod").ZodNumber;
+                recent: import("zod").ZodArray<import("zod").ZodObject<{
+                    time: import("zod").ZodNumber;
+                    tool: import("zod").ZodString;
+                    attributed: import("zod").ZodBoolean;
+                    domain: import("zod").ZodString;
+                    scheme: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"http">, import("zod").ZodLiteral<"https">, import("zod").ZodNull]>;
+                    port: import("zod").ZodNullable<import("zod").ZodNumber>;
+                    action: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"deny">, import("zod").ZodLiteral<"ask">]>;
+                    mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
+                    matched: import("zod").ZodBoolean;
+                    source: import("zod").ZodString;
+                    ruleIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                    reason: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                sources: import("zod").ZodArray<import("zod").ZodObject<{
+                    path: import("zod").ZodString;
+                    exists: import("zod").ZodBoolean;
+                    cwd: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
+        }>;
+        readonly sourceLocation: Readonly<{
+            file: "src/wire.ts";
+            line: 1;
+            column: 1;
+        }>;
+    }> | Readonly<{
+        readonly id: "dsh-permission-rules#permissionRules/rulesRead";
+        readonly service: "permissionRules";
+        readonly namespace: "permissionRules";
+        readonly method: "rulesRead";
+        readonly invocation: Readonly<{
+            kind: "direct";
+        }>;
+        readonly parameters: readonly Readonly<{
+            name: string;
+            wire: string;
+            source: "json";
+            codec: Readonly<{
+                mode: "strict";
+                typeSymbol: "dsh-permission-rules/types#RulesReadRequestPath";
+                schema: import("zod").ZodString;
+            }>;
+        }>[];
+        readonly result: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesReadResult";
+            schema: import("zod").ZodObject<{
+                path: import("zod").ZodString;
+                exists: import("zod").ZodBoolean;
+                text: import("zod").ZodString;
+                error: import("zod").ZodNullable<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        }>;
+        readonly sourceLocation: Readonly<{
+            file: "src/wire.ts";
+            line: 1;
+            column: 1;
+        }>;
+    }> | Readonly<{
+        readonly id: "dsh-permission-rules#permissionRules/rulesSave";
+        readonly service: "permissionRules";
+        readonly namespace: "permissionRules";
+        readonly method: "rulesSave";
+        readonly invocation: Readonly<{
+            kind: "direct";
+        }>;
+        readonly parameters: readonly (Readonly<{
+            name: string;
+            wire: string;
+            source: "json";
+            codec: Readonly<{
+                mode: "strict";
+                typeSymbol: "dsh-permission-rules/types#RulesSaveRequestPath";
+                schema: import("zod").ZodString;
+            }>;
+        }> | Readonly<{
+            name: string;
+            wire: string;
+            source: "json";
+            codec: Readonly<{
+                mode: "strict";
+                typeSymbol: "dsh-permission-rules/types#RulesSaveRequestText";
+                schema: import("zod").ZodString;
+            }>;
+        }>)[];
+        readonly result: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesSaveResult";
+            schema: import("zod").ZodObject<{
+                ok: import("zod").ZodBoolean;
+                error: import("zod").ZodNullable<import("zod").ZodString>;
+                reloaded: import("zod").ZodNullable<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>;
+        }>;
+        readonly sourceLocation: Readonly<{
+            file: "src/wire.ts";
+            line: 1;
+            column: 1;
+        }>;
+    }> | Readonly<{
+        readonly id: "dsh-permission-rules#permissionRules/reload";
+        readonly service: "permissionRules";
+        readonly namespace: "permissionRules";
+        readonly method: "reload";
+        readonly invocation: Readonly<{
+            kind: "direct";
+        }>;
+        readonly parameters: readonly never[];
+        readonly result: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesReloadResult";
+            schema: import("zod").ZodObject<{
+                ok: import("zod").ZodBoolean;
+                error: import("zod").ZodNullable<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        }>;
+        readonly sourceLocation: Readonly<{
+            file: "src/wire.ts";
+            line: 1;
+            column: 1;
+        }>;
+    }>)[];
+    model: Readonly<{
+        services: readonly never[];
+        events: readonly never[];
+        objects: readonly never[];
+    }>;
+}>;
+//# sourceMappingURL=typert.host.d.ts.map

package/lib/types/typert.host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typert.host.d.ts","sourceRoot":"","sources":["../../src/typert.host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,4EAA4E;AAC5E,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUjB,CAAA"}

package/lib/types/wire.d.ts

@@ -0,0 +1,421 @@
+/**
+ * The settings-page wire vocabulary: the snapshot/rule-editor types served
+ * over the `permissionRules` Typert Remote namespace, their zod v4
+ * validation schemas (the strict codec both Typert faces carry), and the
+ * invocation descriptors shared verbatim by the host `./typert` manifest
+ * and the client Remote contribution. One canonical source for both faces
+ * keeps the host and client codecs from ever drifting apart.
+ * @module dsh-permission-rules/wire
+ */
+import { z } from 'zod';
+/** The three network policy modes (wire vocabulary). */
+export type NetworkModeWire = 'deny-all' | 'whitelist' | 'allow-all';
+/** One recent proxy-layer block, sanitized for display. */
+export interface NetworkBlockView {
+    /** Epoch ms of the block. */
+    time: number;
+    /** Attributed shell tool (`bash`/`pwsh`) or `subprocess`. */
+    tool: string;
+    /** Whether an in-flight shell execution could be named. */
+    attributed: boolean;
+    /** Blocked target host. */
+    domain: string;
+    scheme: 'http' | 'https' | null;
+    port: number | null;
+    action: 'deny' | 'ask';
+    mode: NetworkModeWire;
+    /** Whether a rule (true) or the mode default (false) blocked the target. */
+    matched: boolean;
+    source: string;
+    ruleIndex: number | null;
+    reason: string | null;
+}
+/** One rule file the editor may read/write (a known rule source only). */
+export interface RuleSourceView {
+    path: string;
+    exists: boolean;
+    /** The workspace the source belongs to, or null for the deployment fallback. */
+    cwd: string | null;
+}
+/** The complete settings-page snapshot served by `permissionRules/networkStatus`. */
+export interface PermissionRulesSnapshot {
+    enabled: boolean;
+    mode: NetworkModeWire;
+    /** The configured mode knob (`auto` or an explicit mode). */
+    configuredMode: 'auto' | NetworkModeWire;
+    /** The sandbox preset `auto` mapped from, or null. */
+    sandboxMode: string | null;
+    proxyPort: number;
+    proxyActive: boolean;
+    denied: number;
+    askBlocked: number;
+    recent: readonly NetworkBlockView[];
+    sources: readonly RuleSourceView[];
+}
+/** Strict wire schema for {@link PermissionRulesSnapshot}. */
+export declare const PERMISSION_RULES_SNAPSHOT_SCHEMA: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    mode: z.ZodUnion<readonly [z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+    configuredMode: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+    sandboxMode: z.ZodNullable<z.ZodString>;
+    proxyPort: z.ZodNumber;
+    proxyActive: z.ZodBoolean;
+    denied: z.ZodNumber;
+    askBlocked: z.ZodNumber;
+    recent: z.ZodArray<z.ZodObject<{
+        time: z.ZodNumber;
+        tool: z.ZodString;
+        attributed: z.ZodBoolean;
+        domain: z.ZodString;
+        scheme: z.ZodUnion<readonly [z.ZodLiteral<"http">, z.ZodLiteral<"https">, z.ZodNull]>;
+        port: z.ZodNullable<z.ZodNumber>;
+        action: z.ZodUnion<readonly [z.ZodLiteral<"deny">, z.ZodLiteral<"ask">]>;
+        mode: z.ZodUnion<readonly [z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+        matched: z.ZodBoolean;
+        source: z.ZodString;
+        ruleIndex: z.ZodNullable<z.ZodNumber>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    sources: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        exists: z.ZodBoolean;
+        cwd: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Result of `permissionRules/rulesRead`. */
+export interface RulesReadResult {
+    path: string;
+    exists: boolean;
+    text: string;
+    error: string | null;
+}
+/** Strict wire schema for {@link RulesReadResult}. */
+export declare const RULES_READ_SCHEMA: z.ZodObject<{
+    path: z.ZodString;
+    exists: z.ZodBoolean;
+    text: z.ZodString;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** Result of `permissionRules/rulesSave`. */
+export interface RulesSaveResult {
+    ok: boolean;
+    error: string | null;
+    reloaded: number | null;
+}
+/** Strict wire schema for {@link RulesSaveResult}. */
+export declare const RULES_SAVE_SCHEMA: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodNullable<z.ZodString>;
+    reloaded: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+/** Result of `permissionRules/reload`. */
+export interface RulesReloadResult {
+    ok: boolean;
+    error: string | null;
+}
+/** Strict wire schema for {@link RulesReloadResult}. */
+export declare const RULES_RELOAD_SCHEMA: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** The `permissionRules/networkStatus` invocation descriptor (no parameters). */
+export declare const NETWORK_STATUS_DESCRIPTOR: Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/networkStatus";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "networkStatus";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly never[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#PermissionRulesSnapshot";
+        schema: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            mode: z.ZodUnion<readonly [z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+            configuredMode: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+            sandboxMode: z.ZodNullable<z.ZodString>;
+            proxyPort: z.ZodNumber;
+            proxyActive: z.ZodBoolean;
+            denied: z.ZodNumber;
+            askBlocked: z.ZodNumber;
+            recent: z.ZodArray<z.ZodObject<{
+                time: z.ZodNumber;
+                tool: z.ZodString;
+                attributed: z.ZodBoolean;
+                domain: z.ZodString;
+                scheme: z.ZodUnion<readonly [z.ZodLiteral<"http">, z.ZodLiteral<"https">, z.ZodNull]>;
+                port: z.ZodNullable<z.ZodNumber>;
+                action: z.ZodUnion<readonly [z.ZodLiteral<"deny">, z.ZodLiteral<"ask">]>;
+                mode: z.ZodUnion<readonly [z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+                matched: z.ZodBoolean;
+                source: z.ZodString;
+                ruleIndex: z.ZodNullable<z.ZodNumber>;
+                reason: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            sources: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                exists: z.ZodBoolean;
+                cwd: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}>;
+/** The `permissionRules/rulesRead` invocation descriptor. */
+export declare const RULES_READ_DESCRIPTOR: Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/rulesRead";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "rulesRead";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly Readonly<{
+        name: string;
+        wire: string;
+        source: "json";
+        codec: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesReadRequestPath";
+            schema: z.ZodString;
+        }>;
+    }>[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#RulesReadResult";
+        schema: z.ZodObject<{
+            path: z.ZodString;
+            exists: z.ZodBoolean;
+            text: z.ZodString;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}>;
+/** The `permissionRules/rulesSave` invocation descriptor. */
+export declare const RULES_SAVE_DESCRIPTOR: Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/rulesSave";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "rulesSave";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly (Readonly<{
+        name: string;
+        wire: string;
+        source: "json";
+        codec: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesSaveRequestPath";
+            schema: z.ZodString;
+        }>;
+    }> | Readonly<{
+        name: string;
+        wire: string;
+        source: "json";
+        codec: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesSaveRequestText";
+            schema: z.ZodString;
+        }>;
+    }>)[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#RulesSaveResult";
+        schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodNullable<z.ZodString>;
+            reloaded: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}>;
+/** The `permissionRules/reload` invocation descriptor (no parameters). */
+export declare const RULES_RELOAD_DESCRIPTOR: Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/reload";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "reload";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly never[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#RulesReloadResult";
+        schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}>;
+/**
+ * The canonical invocation list both Typert faces register — the host
+ * manifest and the client contribution share these exact descriptor
+ * objects, so the two wire codecs can never drift apart.
+ */
+export declare const PERMISSION_RULES_INVOCATIONS: readonly (Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/networkStatus";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "networkStatus";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly never[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#PermissionRulesSnapshot";
+        schema: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            mode: z.ZodUnion<readonly [z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+            configuredMode: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+            sandboxMode: z.ZodNullable<z.ZodString>;
+            proxyPort: z.ZodNumber;
+            proxyActive: z.ZodBoolean;
+            denied: z.ZodNumber;
+            askBlocked: z.ZodNumber;
+            recent: z.ZodArray<z.ZodObject<{
+                time: z.ZodNumber;
+                tool: z.ZodString;
+                attributed: z.ZodBoolean;
+                domain: z.ZodString;
+                scheme: z.ZodUnion<readonly [z.ZodLiteral<"http">, z.ZodLiteral<"https">, z.ZodNull]>;
+                port: z.ZodNullable<z.ZodNumber>;
+                action: z.ZodUnion<readonly [z.ZodLiteral<"deny">, z.ZodLiteral<"ask">]>;
+                mode: z.ZodUnion<readonly [z.ZodLiteral<"deny-all">, z.ZodLiteral<"whitelist">, z.ZodLiteral<"allow-all">]>;
+                matched: z.ZodBoolean;
+                source: z.ZodString;
+                ruleIndex: z.ZodNullable<z.ZodNumber>;
+                reason: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            sources: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                exists: z.ZodBoolean;
+                cwd: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}> | Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/rulesRead";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "rulesRead";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly Readonly<{
+        name: string;
+        wire: string;
+        source: "json";
+        codec: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesReadRequestPath";
+            schema: z.ZodString;
+        }>;
+    }>[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#RulesReadResult";
+        schema: z.ZodObject<{
+            path: z.ZodString;
+            exists: z.ZodBoolean;
+            text: z.ZodString;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}> | Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/rulesSave";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "rulesSave";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly (Readonly<{
+        name: string;
+        wire: string;
+        source: "json";
+        codec: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesSaveRequestPath";
+            schema: z.ZodString;
+        }>;
+    }> | Readonly<{
+        name: string;
+        wire: string;
+        source: "json";
+        codec: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-permission-rules/types#RulesSaveRequestText";
+            schema: z.ZodString;
+        }>;
+    }>)[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#RulesSaveResult";
+        schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodNullable<z.ZodString>;
+            reloaded: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}> | Readonly<{
+    readonly id: "dsh-permission-rules#permissionRules/reload";
+    readonly service: "permissionRules";
+    readonly namespace: "permissionRules";
+    readonly method: "reload";
+    readonly invocation: Readonly<{
+        kind: "direct";
+    }>;
+    readonly parameters: readonly never[];
+    readonly result: Readonly<{
+        mode: "strict";
+        typeSymbol: "dsh-permission-rules/types#RulesReloadResult";
+        schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }>;
+    readonly sourceLocation: Readonly<{
+        file: "src/wire.ts";
+        line: 1;
+        column: 1;
+    }>;
+}>)[];
+//# sourceMappingURL=wire.d.ts.map

package/lib/types/wire.d.ts.map

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