ran formatter and added ci

.github/workflows/deno.yml

···
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# This workflow will install Deno then run `deno lint` and `deno test`.
+# For more information see: https://github.com/denoland/setup-deno
+
+name: Deno
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Setup repo
+        uses: actions/checkout@v4
+
+      - name: Setup Deno
+        uses: denoland/setup-deno@v1
+        with:
+          deno-version: v2.x
+
+      - name: Verify formatting
+        run: deno fmt --check
+
+      - name: Run linter
+        run: deno lint
+
+      - name: Run type checker
+        run: deno check
+
+      - name: Run tests
+        run: deno test -A

README.md

···
 # typed-lexicon
 
 > [!WARNING]
-> this project is in the middle of active initial development and not ready for use. there will be updates posted [here](https://bsky.app/profile/tylur.dev) if you'd like to follow along! or checkout the [todo.md](./todo.md)
+> this project is in the middle of active initial development and not ready for
+> use. there will be updates posted [here](https://bsky.app/profile/tylur.dev)
+> if you'd like to follow along! or checkout the [todo.md](./todo.md)
 
-this will be a toolkit for writing lexicon json schema's in typescript and providing types for lexicon data shape. it will:
+this will be a toolkit for writing lexicon json schema's in typescript and
+providing types for lexicon data shape. it will:
 
 - remove boilerplate and improve ergonomics
-- type hint for [atproto type parameters](https://atproto.com/specs/lexicon#overview-of-types)
-- infer the typescript type definitions for the data shape to avoid duplication and skew
+- type hint for
+  [atproto type parameters](https://atproto.com/specs/lexicon#overview-of-types)
+- infer the typescript type definitions for the data shape to avoid duplication
+  and skew
 - methods and a cli for generating json
 
-With each of the above finished, i'll plan to write a `validate` method that will be published alongside this that takes any lexicon json definition and validates payloads off that.
+With each of the above finished, i'll plan to write a `validate` method that
+will be published alongside this that takes any lexicon json definition and
+validates payloads off that.
 
-My working hypothesis: it will be easier to write lexicons in typescript with a single api, then validate based off the json definition, than it would be to start with validation library types (standard-schema style) and attempt to use those as the authoring and validation tools.
+My working hypothesis: it will be easier to write lexicons in typescript with a
+single api, then validate based off the json definition, than it would be to
+start with validation library types (standard-schema style) and attempt to use
+those as the authoring and validation tools.
 
 **what you'd write:**
 

src/lib.ts

···
  */
 export const lx = {
   null(
-    options?: LexiconItemCommonOptions
+    options?: LexiconItemCommonOptions,
   ): { type: "null" } & LexiconItemCommonOptions {
     return {
       type: "null",
···
     } as T & { type: "string" };
   },
   unknown(
-    options?: LexiconItemCommonOptions
+    options?: LexiconItemCommonOptions,
   ): { type: "unknown" } & LexiconItemCommonOptions {
     return {
       type: "unknown",
···
   },
   array<Items extends LexiconItem, Options extends ArrayOptions>(
     items: Items,
-    options?: Options
+    options?: Options,
   ): Options & { type: "array"; items: Items } {
     return {
       type: "array",
···
     } as Options & { type: "array"; items: Items };
   },
   token<Description extends string>(
-    description: Description
+    description: Description,
   ): { type: "token"; description: Description } {
     return { type: "token", description };
   },
   ref<Ref extends string>(
     ref: Ref,
-    options?: LexiconItemCommonOptions
+    options?: LexiconItemCommonOptions,
   ): LexiconItemCommonOptions & { type: "ref"; ref: Ref } {
     return {
       type: "ref",
···
   },
   union<const Refs extends readonly string[], Options extends UnionOptions>(
     refs: Refs,
-    options?: Options
+    options?: Options,
   ): Options & { type: "union"; refs: Refs } {
     return {
       type: "union",
···
   },
   object<T extends ObjectProperties>(options: T): ObjectResult<T> {
     const required = Object.keys(options).filter(
-      (key) => options[key].required
+      (key) => options[key].required,
     );
     const nullable = Object.keys(options).filter(
-      (key) => options[key].nullable
+      (key) => options[key].nullable,
     );
     const result: ObjectResult<T> = {
       type: "object",
···
     return result;
   },
   params<Properties extends ParamsProperties>(
-    properties: Properties
+    properties: Properties,
   ): ParamsResult<Properties> {
     const required = Object.keys(properties).filter(
-      (key) => properties[key].required
+      (key) => properties[key].required,
     );
     const result: {
       type: "params";
···
     } as T & { type: "query" };
   },
   procedure<T extends ProcedureOptions>(
-    options?: T
+    options?: T,
   ): T & { type: "procedure" } {
     return {
       type: "procedure",
···
     } as T & { type: "procedure" };
   },
   subscription<T extends SubscriptionOptions>(
-    options?: T
+    options?: T,
   ): T & { type: "subscription" } {
     return {
       type: "subscription",
···
   },
   namespace<ID extends string, D extends LexiconNamespace["defs"]>(
     id: ID,
-    defs: D
+    defs: D,
   ): { lexicon: 1; id: ID; defs: D } {
     return {
       lexicon: 1,

tests/bsky-actor.test.ts

···
     followedBy: lx.string({ format: "at-uri" }),
     knownFollowers: lx.ref("#knownFollowers"),
     activitySubscription: lx.ref(
-      "app.bsky.notification.defs#activitySubscription"
+      "app.bsky.notification.defs#activitySubscription",
     ),
   });
 
···
       "#labelersPref",
       "#postInteractionSettingsPref",
       "#verificationPrefs",
-    ])
+    ]),
   );
 
   assertEquals(preferences, {
···
         "app.bsky.feed.threadgate#followingRule",
         "app.bsky.feed.threadgate#listRule",
       ]),
-      { maxLength: 5 }
+      { maxLength: 5 },
     ),
     postgateEmbeddingRules: lx.array(
       lx.union(["app.bsky.feed.postgate#disableRule"]),
-      { maxLength: 5 }
+      { maxLength: 5 },
     ),
   });
 
···
       followedBy: lx.string({ format: "at-uri" }),
       knownFollowers: lx.ref("#knownFollowers"),
       activitySubscription: lx.ref(
-        "app.bsky.notification.defs#activitySubscription"
+        "app.bsky.notification.defs#activitySubscription",
       ),
     }),
   });

tests/bsky-feed.test.ts

···
     post: lx.ref("#postView", { required: true }),
     parent: lx.union(["#threadViewPost", "#notFoundPost", "#blockedPost"]),
     replies: lx.array(
-      lx.union(["#threadViewPost", "#notFoundPost", "#blockedPost"])
+      lx.union(["#threadViewPost", "#notFoundPost", "#blockedPost"]),
     ),
     threadContext: lx.ref("#threadContext"),
   });
···
 
 Deno.test("app.bsky.feed.defs - requestLess token", () => {
   const requestLess = lx.token(
-    "Request that less content like the given feed item be shown in the feed"
+    "Request that less content like the given feed item be shown in the feed",
   );
 
   assertEquals(requestLess, {
···
 
 Deno.test("app.bsky.feed.defs - requestMore token", () => {
   const requestMore = lx.token(
-    "Request that more content like the given feed item be shown in the feed"
+    "Request that more content like the given feed item be shown in the feed",
   );
 
   assertEquals(requestMore, {
···
 
 Deno.test("app.bsky.feed.defs - clickthroughAuthor token", () => {
   const clickthroughAuthor = lx.token(
-    "User clicked through to the author of the feed item"
+    "User clicked through to the author of the feed item",
   );
 
   assertEquals(clickthroughAuthor, {
···
 
 Deno.test("app.bsky.feed.defs - clickthroughReposter token", () => {
   const clickthroughReposter = lx.token(
-    "User clicked through to the reposter of the feed item"
+    "User clicked through to the reposter of the feed item",
   );
 
   assertEquals(clickthroughReposter, {
···
 
 Deno.test("app.bsky.feed.defs - clickthroughEmbed token", () => {
   const clickthroughEmbed = lx.token(
-    "User clicked through to the embedded content of the feed item"
+    "User clicked through to the embedded content of the feed item",
   );
 
   assertEquals(clickthroughEmbed, {
···
 
 Deno.test("app.bsky.feed.defs - contentModeUnspecified token", () => {
   const contentModeUnspecified = lx.token(
-    "Declares the feed generator returns any types of posts."
+    "Declares the feed generator returns any types of posts.",
   );
 
   assertEquals(contentModeUnspecified, {
···
 
 Deno.test("app.bsky.feed.defs - contentModeVideo token", () => {
   const contentModeVideo = lx.token(
-    "Declares the feed generator returns posts containing app.bsky.embed.video embeds."
+    "Declares the feed generator returns posts containing app.bsky.embed.video embeds.",
   );
 
   assertEquals(contentModeVideo, {
···
       pinned: lx.boolean(),
     }),
     requestLess: lx.token(
-      "Request that less content like the given feed item be shown in the feed"
+      "Request that less content like the given feed item be shown in the feed",
     ),
     requestMore: lx.token(
-      "Request that more content like the given feed item be shown in the feed"
+      "Request that more content like the given feed item be shown in the feed",
     ),
     clickthroughItem: lx.token("User clicked through to the feed item"),
     clickthroughAuthor: lx.token(
-      "User clicked through to the author of the feed item"
+      "User clicked through to the author of the feed item",
     ),
     clickthroughReposter: lx.token(
-      "User clicked through to the reposter of the feed item"
+      "User clicked through to the reposter of the feed item",
     ),
     clickthroughEmbed: lx.token(
-      "User clicked through to the embedded content of the feed item"
+      "User clicked through to the embedded content of the feed item",
     ),
     contentModeUnspecified: lx.token(
-      "Declares the feed generator returns any types of posts."
+      "Declares the feed generator returns any types of posts.",
     ),
     contentModeVideo: lx.token(
-      "Declares the feed generator returns posts containing app.bsky.embed.video embeds."
+      "Declares the feed generator returns posts containing app.bsky.embed.video embeds.",
     ),
     interactionSeen: lx.token("Feed item was seen by user"),
     interactionLike: lx.token("User liked the feed item"),

tests/primitives.test.ts

···
 
 Deno.test("lx.cidLink()", () => {
   const result = lx.cidLink(
-    "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a"
+    "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
   );
   assertEquals(result, {
     type: "cid-link",
···
 
 Deno.test("lx.token() with interaction event", () => {
   const result = lx.token(
-    "Request that less content like the given feed item be shown in the feed"
+    "Request that less content like the given feed item be shown in the feed",
   );
   assertEquals(result, {
     type: "token",
···
 
 Deno.test("lx.token() with content mode", () => {
   const result = lx.token(
-    "Declares the feed generator returns posts containing app.bsky.embed.video embeds"
+    "Declares the feed generator returns posts containing app.bsky.embed.video embeds",
   );
   assertEquals(result, {
     type: "token",

todo.md

···
 Build a toolkit for writing ATProto lexicon JSON schemas in TypeScript that:
 
 - Removes boilerplate and improves ergonomics
-- Provides type hints for [atproto type parameters](https://atproto.com/specs/lexicon#overview-of-types)
-- Infers TypeScript type definitions for data shapes to avoid duplication and skew
+- Provides type hints for
+  [atproto type parameters](https://atproto.com/specs/lexicon#overview-of-types)
+- Infers TypeScript type definitions for data shapes to avoid duplication and
+  skew
 - Includes methods and a CLI for generating JSON
 
 ## Files to Read
···
 - **Main spec**: https://atproto.com/specs/lexicon#overview-of-types
 - **Data model**: https://atproto.com/specs/data-model
 - **ATProto lexicon examples**:
-  - https://github.com/bluesky-social/atproto/blob/main/lexicons/app/bsky/actor/defs.json (for `ref` examples)
-  - https://github.com/bluesky-social/atproto/blob/main/lexicons/app/bsky/feed/defs.json (for `token` examples)
+  - https://github.com/bluesky-social/atproto/blob/main/lexicons/app/bsky/actor/defs.json
+    (for `ref` examples)
+  - https://github.com/bluesky-social/atproto/blob/main/lexicons/app/bsky/feed/defs.json
+    (for `token` examples)
 
 ## Implementation Status
 
···
 
 ## todo
 
-write two new test files, one for bsky actor and another for bsky feed. i want to see these fully implemented and tested in separate files. then wait.
+write two new test files, one for bsky actor and another for bsky feed. i want
+to see these fully implemented and tested in separate files. then wait.