@try-works/dsh-model-as-tool 0.1.3 → 0.3.6

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/standard.js

@@ -0,0 +1,445 @@
+/**
+ * The remaining standard tool contracts (EXT-21, task-69).
+ *
+ * These descriptors are SCHEMAS AND SEMANTICS ONLY — no model bindings, no
+ * weights, no host code (EXT-17). Each is a closed schema with honest
+ * `semantics`, `limits` and `unsupported` records, matching the vocabulary the
+ * host registers and the extension packages implement against.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/standard
+ */
+import { withMeta } from "../meta.js";
+/** The `text.title` contract at version 1.0.0 (RCP-12). */
+export const textTitle = {
+    contract: 'text.title',
+    version: '1.0.0',
+    toolName: 'text_title',
+    description: 'Propose a bounded title and one-sentence description for supplied text through an authorized harness model.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            kind: { type: 'string', enum: ['section', 'page', 'document'], default: 'section' },
+            repairFeedback: { type: 'string', minLength: 1, maxLength: 512 },
+        },
+    },
+    outputSchema: withMeta({
+        title: { type: 'string', minLength: 1, maxLength: 80 },
+        description: { type: 'string', minLength: 1, maxLength: 240 },
+    }, ['title', 'description']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxInputCharacters: 32768,
+        maxTitleCharacters: 80,
+        maxDescriptionCharacters: 240,
+        maxRepairs: 1,
+    },
+    unsupported: [
+        'Invented facts: the title must state only what the text supports.',
+        'Empty titles and descriptions.',
+    ],
+};
+/** The `image.describe` contract at version 1.0.0 (HLM-12). */
+export const imageDescribe = {
+    contract: 'image.describe',
+    version: '1.0.0',
+    toolName: 'describe_image',
+    description: 'Describe the visible content of an approved image through an authorized harness model, with honest uncertainty.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['image_path'],
+        properties: {
+            image_path: { type: 'string', minLength: 1, description: 'An approved image resolved by the host.' },
+            focus: { type: 'string', minLength: 1, maxLength: 500 },
+        },
+    },
+    outputSchema: withMeta({
+        description: { type: 'string', minLength: 1 },
+    }, ['description']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'visible-image-content',
+    },
+    limits: {
+        maxImages: 1,
+        maxFocusCharacters: 500,
+    },
+    unsupported: [
+        'Invented hidden facts, exact OCR or full transcription claims.',
+        'Treating text drawn in the image as instructions.',
+    ],
+};
+/** The `embed.multimodal` contract at version 1.0.0 (EmbeddingGemma family). */
+export const multimodalEmbed = {
+    contract: 'embed.multimodal',
+    version: '1.0.0',
+    toolName: 'multimodal_embed',
+    description: 'Embed a text, image or audio input into a shared vector space.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['input'],
+        properties: {
+            input: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['kind'],
+                properties: {
+                    kind: { type: 'string', enum: ['text', 'image', 'audio'] },
+                    text: { type: 'string', minLength: 1, maxLength: 32768 },
+                    media: { type: 'string', description: 'An approved media reference resolved by the host.' },
+                },
+            },
+        },
+    },
+    outputSchema: withMeta({
+        embedding: { type: 'array', items: { type: 'number' }, minItems: 1 },
+        dimensions: { type: 'integer', minimum: 1 },
+    }, ['embedding', 'dimensions']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'text-image-audio',
+    },
+    limits: {
+        maxInputCharacters: 32768,
+        maxMediaBytes: 8388608,
+    },
+    unsupported: ['Video frames beyond the declared sampler.'],
+};
+/** The `semantic.similarity` contract at version 1.0.0. */
+export const semanticSimilarity = {
+    contract: 'semantic.similarity',
+    version: '1.0.0',
+    toolName: 'semantic_similarity',
+    description: 'Score the similarity of two bounded texts.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['left', 'right'],
+        properties: {
+            left: { type: 'string', minLength: 1, maxLength: 32768 },
+            right: { type: 'string', minLength: 1, maxLength: 32768 },
+        },
+    },
+    outputSchema: withMeta({ score: { type: 'number' } }, ['score']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxInputCharacters: 32768 },
+    unsupported: ['Calibrated probabilities.'],
+};
+/** The `semantic.rank` contract at version 1.0.0. */
+export const semanticRank = {
+    contract: 'semantic.rank',
+    version: '1.0.0',
+    toolName: 'semantic_rank',
+    description: 'Rank candidates by semantic distance to a query.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['query', 'candidates'],
+        properties: {
+            query: { type: 'string', minLength: 1, maxLength: 4096 },
+            candidates: {
+                type: 'array', minItems: 1, maxItems: 100,
+                items: { type: 'string', minLength: 1, maxLength: 8192 },
+            },
+        },
+    },
+    outputSchema: withMeta({
+        ranked: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['index', 'score'],
+                properties: { index: { type: 'integer', minimum: 0 }, score: { type: 'number' } },
+            },
+        },
+    }, ['ranked']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxCandidates: 100 },
+    unsupported: ['Calibrated probabilities.'],
+};
+/** The `semantic.classify` contract at version 1.0.0. */
+export const semanticClassify = {
+    contract: 'semantic.classify',
+    version: '1.0.0',
+    toolName: 'semantic_classify',
+    description: 'Classify a text into the closest of the supplied labels, with the ability to abstain.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text', 'labels'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            labels: { type: 'array', minItems: 1, maxItems: 64, items: { type: 'string', minLength: 1, maxLength: 200 } },
+        },
+    },
+    outputSchema: withMeta({
+        label: { type: ['string', 'null'] },
+        abstained: { type: 'boolean' },
+        scores: { type: 'array', items: { type: 'number' } },
+    }, ['label', 'abstained', 'scores']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxLabels: 64 },
+    unsupported: ['Forcing a label when every score is below the abstain margin.'],
+};
+/** The `semantic.deduplicate` contract at version 1.0.0. */
+export const semanticDeduplicate = {
+    contract: 'semantic.deduplicate',
+    version: '1.0.0',
+    toolName: 'semantic_deduplicate',
+    description: 'Group near-duplicate texts into greedy clusters around their representatives.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['texts'],
+        properties: {
+            texts: { type: 'array', minItems: 1, maxItems: 1000, items: { type: 'string', minLength: 1, maxLength: 8192 } },
+        },
+    },
+    outputSchema: withMeta({
+        groups: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['members'],
+                properties: { members: { type: 'array', items: { type: 'integer', minimum: 0 } } },
+            },
+        },
+    }, ['groups']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxTexts: 1000 },
+    unsupported: ['Transitive-closure equivalence: clustering is greedy, not global.'],
+};
+/** The `media.find_moments` contract at version 1.0.0. */
+export const mediaFindMoments = {
+    contract: 'media.find_moments',
+    version: '1.0.0',
+    toolName: 'media_find_moments',
+    description: 'Find the media windows most relevant to a query within approved media.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['media', 'query'],
+        properties: {
+            media: { type: 'string', description: 'An approved media reference resolved by the host.' },
+            query: { type: 'string', minLength: 1, maxLength: 4096 },
+        },
+    },
+    outputSchema: withMeta({
+        windows: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['startMs', 'endMs', 'score'],
+                properties: {
+                    startMs: { type: 'number', minimum: 0 },
+                    endMs: { type: 'number', minimum: 0 },
+                    score: { type: 'number' },
+                },
+            },
+        },
+    }, ['windows']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'approved-media',
+    },
+    limits: { maxWindows: 32, maxQueryCharacters: 4096 },
+    unsupported: ['Windows outside the approved media bounds.'],
+};
+/** The `decision.choose` contract at version 1.0.0 (Laya family). */
+export const decisionChoose = {
+    contract: 'decision.choose',
+    version: '1.0.0',
+    toolName: 'decision_choose',
+    description: 'Choose one option from a bounded set for a stated decision, with a confidence verdict.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['decision', 'options'],
+        properties: {
+            decision: { type: 'string', minLength: 1, maxLength: 4096 },
+            options: { type: 'array', minItems: 2, maxItems: 16, items: { type: 'string', minLength: 1, maxLength: 400 } },
+        },
+    },
+    outputSchema: withMeta({
+        chosen: { type: 'integer', minimum: 0 },
+        confidence: { type: 'string', enum: ['confident', 'likely', 'tentative'] },
+        reason: { type: 'string', minLength: 1 },
+    }, ['chosen', 'confidence', 'reason']),
+    semantics: {
+        scoreKind: 'vendor-reported-confidence',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'stated-decision',
+    },
+    limits: { maxOptions: 16 },
+    unsupported: ['Open-ended generation: this contract chooses, it does not compose.'],
+};
+/** The `decision.test` contract at version 1.0.0. */
+export const decisionTest = {
+    contract: 'decision.test',
+    version: '1.0.0',
+    toolName: 'decision_test',
+    description: 'Test a binary predicate against supplied text and report the verdict with evidence.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text', 'predicate'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            predicate: { type: 'string', minLength: 1, maxLength: 1000 },
+        },
+    },
+    outputSchema: withMeta({
+        verdict: { type: 'boolean' },
+        confidence: { type: 'string', enum: ['confident', 'likely', 'tentative'] },
+        evidence: { type: 'string', minLength: 1 },
+    }, ['verdict', 'confidence', 'evidence']),
+    semantics: {
+        scoreKind: 'vendor-reported-confidence',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxInputCharacters: 32768 },
+    unsupported: ['Testing predicates about content outside the supplied text.'],
+};
+/** The `decision.score` contract at version 1.0.0. */
+export const decisionScore = {
+    contract: 'decision.score',
+    version: '1.0.0',
+    toolName: 'decision_score',
+    description: 'Score supplied options against one criterion on a declared bounded scale.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['criterion', 'options'],
+        properties: {
+            criterion: { type: 'string', minLength: 1, maxLength: 2000 },
+            options: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', minLength: 1, maxLength: 400 } },
+        },
+    },
+    outputSchema: withMeta({
+        scores: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['index', 'score'],
+                properties: { index: { type: 'integer', minimum: 0 }, score: { type: 'number', minimum: 0, maximum: 10 } },
+            },
+        },
+    }, ['scores']),
+    semantics: {
+        scoreKind: 'bounded-scale-0-10',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'stated-criterion',
+    },
+    limits: { maxOptions: 16 },
+    unsupported: ['Scores outside the declared 0-10 scale.'],
+};
+/** The `structured.extract` contract at version 1.0.0 (Needle family). */
+export const structuredExtract = {
+    contract: 'structured.extract',
+    version: '1.0.0',
+    toolName: 'structured_extract',
+    description: 'Extract typed fields from supplied text against the caller-declared, host-approved schema snapshot.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text', 'schema'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            schema: { type: 'object', description: 'The host-approved extraction schema snapshot (NDL-02).' },
+        },
+    },
+    outputSchema: withMeta({
+        extracted: { type: 'object', description: 'The typed extraction payload.' },
+    }, ['extracted']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxInputCharacters: 32768 },
+    unsupported: ['Executing a caller-supplied schema that the host has not approved.'],
+};
+/** The `plan.tools` contract at version 1.0.0 (Needle family). */
+export const toolsPlan = {
+    contract: 'plan.tools',
+    version: '1.0.0',
+    toolName: 'tools_plan',
+    description: 'Propose a read-only tool plan against the host-frozen authorized tool snapshot (NDL-02).',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['objective'],
+        properties: {
+            objective: { type: 'string', minLength: 1, maxLength: 4096 },
+        },
+    },
+    outputSchema: withMeta({
+        proposal: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['tool', 'arguments'],
+                properties: {
+                    tool: { type: 'string', minLength: 1 },
+                    arguments: { type: 'object' },
+                },
+            },
+        },
+    }, ['proposal']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'proposal-only',
+    },
+    limits: { maxObjectiveCharacters: 4096 },
+    unsupported: [
+        'Executing the proposal: this contract proposes; the host re-checks authorization before any dispatch (NDL-03).',
+    ],
+};
+//# sourceMappingURL=standard.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-embed.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `text.embed` — the legacy MiniLM text-embedding contract (TOOL-04, BASE-12).
+ *
+ * Model-free: any conforming implementation binds to it. This is the 384-
+ * dimensional MiniLM space, PRESERVED separately from the EmbeddingGemma 2
+ * 768-dimensional space — the two must never be mixed, and a stored 384-d
+ * index must never be quietly fed 768-wide vectors.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-embed
+ */
+import type { ToolContract } from '../registry.ts';
+/** The `text.embed` contract at version 1.0.0. */
+export declare const textEmbed: ToolContract;
+//# sourceMappingURL=text-embed.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-embed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-embed.d.ts","sourceRoot":"","sources":["../../src/contracts/text-embed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,kDAAkD;AAClD,eAAO,MAAM,SAAS,EAAE,YA0DvB,CAAA"}

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-embed.js

@@ -0,0 +1,63 @@
+/**
+ * `text.embed` — the legacy MiniLM text-embedding contract (TOOL-04, BASE-12).
+ *
+ * Model-free: any conforming implementation binds to it. This is the 384-
+ * dimensional MiniLM space, PRESERVED separately from the EmbeddingGemma 2
+ * 768-dimensional space — the two must never be mixed, and a stored 384-d
+ * index must never be quietly fed 768-wide vectors.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-embed
+ */
+import { withMeta } from "../meta.js";
+/** The `text.embed` contract at version 1.0.0. */
+export const textEmbed = {
+    contract: 'text.embed',
+    version: '1.0.0',
+    toolName: 'text_embed',
+    description: 'Embed a batch of texts into the legacy 384-dimensional MiniLM embedding space (mean pooling, '
+        + 'L2-normalized, input order preserved). This is a compatibility space: stored 384-d vectors and '
+        + 'indexes remain pinned to it, and switching to another model requires explicit re-embedding. '
+        + 'All values are finite; an empty or overlong batch is refused, never silently truncated.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['texts'],
+        properties: {
+            texts: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 32,
+                items: { type: 'string', minLength: 1, maxLength: 32768 },
+                description: 'The texts in the caller\'s order; that order is the embedding order (TOOL-04).',
+            },
+        },
+    },
+    outputSchema: withMeta({
+        embeddings: {
+            type: 'array',
+            items: {
+                type: 'array',
+                items: { type: 'number' },
+                description: 'One 384-dimensional L2-normalized vector per input text, in input order.',
+            },
+        },
+        dimensions: { const: 384 },
+        normalized: { const: true },
+    }, ['embeddings', 'dimensions', 'normalized']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxTexts: 32,
+        maxInputCharacters: 32768,
+        dimensions: 384,
+    },
+    unsupported: [
+        'Mixing 384-dimensional and 768-dimensional vectors in one index.',
+        'Silently truncating an overlong batch.',
+    ],
+};
+//# sourceMappingURL=text-embed.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-rerank.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `text.rerank` — the cross-encoder reranking contract (TOOL-05).
+ *
+ * Model-free: any conforming implementation binds to it. The scores are
+ * RANKING LOGITS from a cross-encoder — not embedding cosines, and the two
+ * score kinds are never interchangeable (the semantic_rank tool's
+ * cosine_similarity is a different quantity).
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-rerank
+ */
+import type { ToolContract } from '../registry.ts';
+/** The `text.rerank` contract at version 1.0.0. */
+export declare const textRerank: ToolContract;
+//# sourceMappingURL=text-rerank.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-rerank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-rerank.d.ts","sourceRoot":"","sources":["../../src/contracts/text-rerank.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,mDAAmD;AACnD,eAAO,MAAM,UAAU,EAAE,YAuExB,CAAA"}

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-rerank.js

@@ -0,0 +1,76 @@
+/**
+ * `text.rerank` — the cross-encoder reranking contract (TOOL-05).
+ *
+ * Model-free: any conforming implementation binds to it. The scores are
+ * RANKING LOGITS from a cross-encoder — not embedding cosines, and the two
+ * score kinds are never interchangeable (the semantic_rank tool's
+ * cosine_similarity is a different quantity).
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-rerank
+ */
+import { withMeta } from "../meta.js";
+/** The `text.rerank` contract at version 1.0.0. */
+export const textRerank = {
+    contract: 'text.rerank',
+    version: '1.0.0',
+    toolName: 'text_rerank',
+    description: 'Score query/document pairs with a cross-encoder and return the caller\'s own ids in descending '
+        + 'ranking-logit order with exact ties broken by input order. The scores are cross-encoder '
+        + 'logits (scoreKind "ranking_logit"), NOT embedding cosines: the two are not interchangeable. '
+        + 'A positive top_k within the candidate count is required when supplied.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['query', 'documents'],
+        properties: {
+            query: { type: 'string', minLength: 1, maxLength: 32768 },
+            documents: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 256,
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['id', 'text'],
+                    properties: {
+                        id: { type: 'string', minLength: 1, maxLength: 128 },
+                        text: { type: 'string', minLength: 1, maxLength: 32768 },
+                    },
+                },
+                description: 'The documents in the caller\'s order; that order breaks exact score ties (TOOL-05).',
+            },
+            top_k: { type: 'integer', minimum: 1, maximum: 256 },
+        },
+    },
+    outputSchema: withMeta({
+        results: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['id', 'score'],
+                properties: {
+                    id: { type: 'string' },
+                    score: { type: 'number' },
+                },
+            },
+        },
+        scoreKind: { const: 'ranking_logit' },
+    }, ['results', 'scoreKind']),
+    semantics: {
+        scoreKind: 'ranking-logit',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxDocuments: 256,
+        maxInputCharacters: 32768,
+        maxTopK: 256,
+    },
+    unsupported: [
+        'Treating ranking logits as embedding cosines.',
+        'Negative or zero top_k when supplied.',
+    ],
+};
+//# sourceMappingURL=text-rerank.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/dsh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dsh.d.ts","sourceRoot":"","sources":["../src/dsh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,wEAAwE;AACxE,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAEhE,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AAEvD,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAA;IAClC;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;CAC5C;AAED,6EAA6E;AAC7E,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAkB,IAAI,qBAAoB;IAC1C,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;gBAC3B,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,MAAM,EAAE;CAO7D;AAyFD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAuBlE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAErE;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;AAElF,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,EAAE,CAqCxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,aAAa,CAsB3F"}
+{"version":3,"file":"dsh.d.ts","sourceRoot":"","sources":["../src/dsh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,wEAAwE;AACxE,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAEhE,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AAEvD,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAA;IAClC;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;CAC5C;AAED,6EAA6E;AAC7E,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAkB,IAAI,qBAAoB;IAC1C,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;gBAC3B,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,MAAM,EAAE;CAO7D;AAuHD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAuBlE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAErE;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;AAElF,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,EAAE,CAqCxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,aAAa,CAiB3F"}