fix remaining tests

packages/emitter/test/integration/lexicon-examples/input/sh/tangled/knot.tsp

···
+import "@typelex/emitter";
+
+namespace sh.tangled.knot {
+  @rec("any")
+  model Main {
+    @required createdAt: datetime;
+  }
+}

packages/emitter/test/integration/lexicon-examples/input/sh/tangled/pipeline.tsp

···
+import "@typelex/emitter";
+
+namespace sh.tangled.pipeline {
+  @rec("tid")
+  model Main {
+    @required triggerMetadata: TriggerMetadata;
+    @required workflows: Workflow[];
+  }
+
+  @closed
+  @inline
+  union TriggerKind {
+    "push",
+    "pull_request",
+    "manual",
+  }
+
+  model TriggerMetadata {
+    @required kind: TriggerKind;
+    @required repo: TriggerRepo;
+    push?: PushTriggerData;
+    pullRequest?: PullRequestTriggerData;
+    manual?: ManualTriggerData;
+  }
+
+  model TriggerRepo {
+    @required knot: string;
+    @required did: did;
+    @required repo: string;
+    @required defaultBranch: string;
+  }
+
+  model PushTriggerData {
+    @required ref: string;
+
+    @required
+    @minLength(40)
+    @maxLength(40)
+    newSha: string;
+
+    @required
+    @minLength(40)
+    @maxLength(40)
+    oldSha: string;
+  }
+
+  model PullRequestTriggerData {
+    @required sourceBranch: string;
+    @required targetBranch: string;
+
+    @required
+    @minLength(40)
+    @maxLength(40)
+    sourceSha: string;
+
+    @required action: string;
+  }
+
+  model ManualTriggerData {
+    inputs?: Pair[];
+  }
+
+  model Workflow {
+    @required name: string;
+    @required engine: string;
+    @required clone: CloneOpts;
+    @required raw: string;
+  }
+
+  model CloneOpts {
+    @required skip: boolean;
+    @required depth: integer;
+    @required submodules: boolean;
+  }
+
+  model Pair {
+    @required key: string;
+    @required value: string;
+  }
+}

packages/emitter/test/integration/lexicon-examples/input/sh/tangled/repo/mergeCheck.tsp

···
+import "@typelex/emitter";
+
+namespace sh.tangled.repo.mergeCheck {
+  /** Check if a merge is possible between two branches */
+  @procedure
+  op main(
+    input: {
+      /** DID of the repository owner */
+      @required did: did,
+
+      /** Name of the repository */
+      @required name: string,
+
+      /** Patch or pull request to check for merge conflicts */
+      @required patch: string,
+  
+      /** Target branch to merge into */
+      @required branch: string,
+    }
+  ): {
+    /** Whether the merge has conflicts */
+    @required is_conflicted: boolean;
+
+    /** List of files with merge conflicts */
+    conflicts?: ConflictInfo[];
+
+    /** Additional message about the merge check */
+    message?: string;
+
+    /** Error message if check failed */
+    error?: string;
+  };
+
+  model ConflictInfo {
+    /** Name of the conflicted file */
+    @required filename: string;
+
+    /** Reason for the conflict */
+    @required reason: string;
+  }
+}

packages/emitter/test/integration/lexicon-examples/input/sh/tangled/repo/removeSecret.tsp

···
+import "@typelex/emitter";
+
+namespace sh.tangled.repo.removeSecret {
+  /** Remove a CI secret */
+  @procedure
+  op main(
+    input: {
+      @required repo: atUri,
+
+      @required
+      @minLength(1)
+      @maxLength(50)
+      key: string,
+    }
+  ): void;
+}

packages/emitter/test/integration/lexicon-examples/input/sh/tangled/repo/tags.tsp

···
+import "@typelex/emitter";
+
+namespace sh.tangled.repo.tags {
+  @query
+  @errors(RepoNotFound, InvalidRequest)
+  @encoding("*/*")
+  op main(
+    /** Repository identifier in format 'did:plc:.../repoName' */
+    @required repo: string,
+
+    /** Maximum number of tags to return */
+    @minValue(1)
+    @maxValue(100)
+    limit?: integer = 50,
+
+    /** Pagination cursor */
+    cursor?: string,
+  ): void;
+
+  /** Repository not found or access denied */
+  model RepoNotFound {}
+
+  /** Invalid request parameters */
+  model InvalidRequest {}
+}

packages/emitter/test/integration/lexicon-examples/input/sh/tangled/repo/tree.tsp

···
+import "@typelex/emitter";
+
+namespace sh.tangled.repo.tree {
+  @query
+  @errors(RepoNotFound, RefNotFound, PathNotFound, InvalidRequest)
+  op main(
+    /** Repository identifier in format 'did:plc:.../repoName' */
+    @required repo: string,
+
+    /** Git reference (branch, tag, or commit SHA) */
+    @required ref: string,
+
+    /** Path within the repository tree */
+    path?: string = "",
+  ): {
+    /** The git reference used */
+    @required ref: string;
+
+    /** The parent path in the tree */
+    parent?: string;
+
+    /** Parent directory path */
+    dotdot?: string;
+
+    /** Readme for this file tree */
+    readme?: Readme;
+
+    @required files: TreeEntry[];
+  };
+
+  model Readme {
+    /** Name of the readme file */
+    @required filename: string;
+
+    /** Contents of the readme file */
+    @required contents: string;
+  }
+
+  model TreeEntry {
+    /** Relative file or directory name */
+    @required name: string;
+
+    /** File mode */
+    @required mode: string;
+
+    /** File size in bytes */
+    @required size: integer;
+
+    /** Whether this entry is a file */
+    @required is_file: boolean;
+
+    /** Whether this entry is a directory/subtree */
+    @required is_subtree: boolean;
+
+    last_commit?: LastCommit;
+  }
+
+  model LastCommit {
+    /** Commit hash */
+    @required hash: string;
+
+    /** Commit message */
+    @required message: string;
+
+    /** Commit timestamp */
+    @required when: datetime;
+  }
+
+  /** Repository not found or access denied */
+  model RepoNotFound {}
+
+  /** Git reference not found */
+  model RefNotFound {}
+
+  /** Path not found in repository tree */
+  model PathNotFound {}
+
+  /** Invalid request parameters */
+  model InvalidRequest {}
+}

packages/emitter/test/integration/lexicon-examples/input/sh/tangled/spindle.tsp

···
+import "@typelex/emitter";
+
+namespace sh.tangled.spindle {
+  @rec("any")
+  model Main {
+    @required createdAt: datetime;
+  }
+}

packages/emitter/test/integration/lexicon-examples/output/sh/tangled/string.json

···
-{
-  "lexicon": 1,
-  "id": "sh.tangled.string",
-  "defs": {
-    "main": {
-      "type": "record",
-      "key": "tid",
-      "record": {
-        "type": "object",
-        "required": [
-          "filename",
-          "description",
-          "createdAt",
-          "contents"
-        ],
-        "properties": {
-          "filename": {
-            "type": "string",
-            "maxGraphemes": 140,
-            "minGraphemes": 1
-          },
-          "description": {
-            "type": "string",
-            "maxGraphemes": 280
-          },
-          "createdAt": {
-            "type": "string",
-            "format": "datetime"
-          },
-          "contents": {
-            "type": "string",
-            "minGraphemes": 1
-          }
-        }
-      }
-    }
-  }
-}