@tsdoctor/seo 0.1.0

package/index.d.ts

@@ -0,0 +1,543 @@
+import { PackageManifest } from "@effected/package-json";
+import { Result, Schema } from "effect";
+import { ConflictingTermError, DuplicateNodeIdError, InvalidNodeIdError, JsonLdDocument, JsonLdNode } from "@effected/schema-org";
+//#region src/Attribution.d.ts
+/**
+ * The attribution a page can credit, derived from one package manifest.
+ *
+ * @remarks
+ * `licenseIds` and `primaryLicenseId` are deliberately both present.
+ * `primaryLicenseId` is absent for an `AND` expression, where every term binds
+ * at once and naming one would silently drop a license that legally applies;
+ * `licenseIds` always lists every license named. A consumer wanting one value
+ * reads `primaryLicenseId` and degrades when it is absent; one that can carry
+ * several (schema.org's `license` accepts an array) reads `licenseIds`.
+ *
+ * @public
+ */
+interface AttributionFacts {
+  /** The `author` field's name. */
+  readonly authorName?: string;
+  /** The `author` field's homepage, when it carried one. */
+  readonly authorUrl?: string;
+  /** Every `maintainers` entry's name, in manifest order. */
+  readonly maintainerNames: ReadonlyArray<string>;
+  /**
+   * The browsable URL of **this package** within its repository.
+   *
+   * @remarks
+   * `Repository.directoryUrl` when the host's subdirectory convention is
+   * known, falling back to `Repository.browseUrl` otherwise — see
+   * {@link attributionFacts} for why the fallback is deliberate.
+   */
+  readonly repositoryUrl?: string;
+  /** The `homepage` field, verbatim. */
+  readonly homepage?: string;
+  /**
+   * Every SPDX identifier the `license` expression names, in written order.
+   * Empty when the manifest carries no license, or one that is not SPDX.
+   */
+  readonly licenseIds: ReadonlyArray<string>;
+  /**
+   * The single identifier the expression can be said to be under, absent for
+   * an `AND`.
+   */
+  readonly primaryLicenseId?: string;
+  /**
+   * The canonical SPDX page for {@link AttributionFacts.primaryLicenseId},
+   * absent for a `LicenseRef` or any id outside the catalog.
+   */
+  readonly licenseUrl?: string;
+  /**
+   * The canonical SPDX page for EVERY license the expression names, in
+   * written order, skipping any that has none.
+   *
+   * @remarks
+   * The plural counterpart to {@link AttributionFacts.licenseUrl}, and the
+   * one a consumer wants when the field it is filling accepts several —
+   * schema.org's `license` does. `licenseUrl` names only the primary, and an
+   * `AND` expression has no primary, so a dual-licensed package reading only
+   * the singular gets nothing at all.
+   *
+   * Shorter than `licenseIds` whenever a named license is outside the SPDX
+   * catalog (a `LicenseRef`), which is why the two are not index-aligned.
+   */
+  readonly licenseUrls: ReadonlyArray<string>;
+  /** The `keywords` field, verbatim. */
+  readonly keywords: ReadonlyArray<string>;
+}
+/**
+ * Derive the attribution facts a documentation page can credit from a decoded
+ * package manifest.
+ *
+ * @remarks
+ * Total: a manifest carrying none of these fields yields empty arrays and no
+ * optional properties, never a failure. Per-field degradation is the contract —
+ * an unparseable license drops only the license facts, an unrecognized
+ * repository reference drops only the repository URL.
+ *
+ * @param manifest - the decoded manifest to read
+ * @returns the facts, with every underivable field absent
+ *
+ * @example
+ * ```ts
+ * import { PackageManifest } from "@effected/package-json";
+ * import { attributionFacts } from "@tsdoctor/seo";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const manifest = yield* PackageManifest.decode({
+ *     name: "@scope/pkg",
+ *     version: "1.0.0",
+ *     license: "MIT",
+ *     repository: { url: "github:owner/repo", directory: "packages/pkg" },
+ *   });
+ *   const facts = attributionFacts(manifest);
+ *   console.log(facts.primaryLicenseId, facts.repositoryUrl);
+ *   // => "MIT" "https://github.com/owner/repo/tree/HEAD/packages/pkg"
+ * });
+ * ```
+ *
+ * @public
+ */
+declare function attributionFacts(manifest: PackageManifest): AttributionFacts;
+//#endregion
+//#region src/Canonical.d.ts
+/**
+ * URL derivation for a documentation page: the site URL prefix, the canonical
+ * page URL, absolute image URLs and image MIME mapping.
+ *
+ * @remarks
+ * `imageMimeType`, `resolveUrl` and `deriveSiteUrl` moved here verbatim from
+ * the RSPress adapter's `og-resolver.ts`. `resolveUrl` was `resolveOgUrl`
+ * there; canonical links resolve through the same function, so the
+ * OG-specific name no longer fits. Everything here is total and synchronous —
+ * no Effect, no filesystem.
+ *
+ * @packageDocumentation
+ */
+/**
+ * The `og:image:type` value for a detected image format, or `undefined` for a
+ * format with no mapping.
+ *
+ * @public
+ */
+declare function imageMimeType(type: string | undefined): string | undefined;
+/**
+ * Turn a configured URL into an absolute one.
+ *
+ * @returns The absolute URL, or `undefined` when the input is neither an
+ * absolute `http(s)` URL nor a site-root-relative path. A bare relative path
+ * is deliberately rejected rather than guessed at — there is no base to
+ * resolve it against that would not silently produce a broken link.
+ *
+ * @public
+ */
+declare function resolveUrl(siteUrl: string, url: string): string | undefined;
+/**
+ * Derive the site URL prefix from the framework's own config.
+ *
+ * @remarks
+ * Replaces the RSPress plugin's former `siteUrl` option. RSPress already knows
+ * where a site is deployed — {@link https://rspress.rs/api/config/config-basic#siteorigin | `siteOrigin`}
+ * plus `base` — so asking for it a second time invited the two to disagree, and
+ * a plugin-level answer that contradicted the site's own would silently emit
+ * canonical and `og:url` tags pointing at a host the site is not served from.
+ *
+ * RSPress concatenates as `siteOrigin + base + routePath`, and **this follows
+ * its documented fallback exactly**: with no `siteOrigin`, RSPress uses
+ * `base + routePath`. So an unset origin yields a ROOT-RELATIVE prefix rather
+ * than nothing.
+ *
+ * That fallback is what makes the tags inspectable in `rspress dev`, where the
+ * site is served from `localhost` and no configured origin could be correct
+ * anyway. A root-relative `/images/og.png` resolves against the page's own
+ * origin in the browser; it is a *relative* path (`images/og.png`, no leading
+ * slash) that has no base to resolve against, and this never emits one.
+ *
+ * @returns The prefix to put in front of a route that already begins with `/`.
+ * `""` when the site declares neither `siteOrigin` nor a non-root `base`, which
+ * leaves every URL root-relative. Never has a trailing slash, since every
+ * caller appends a route starting with `/`.
+ *
+ * @public
+ */
+declare function deriveSiteUrl(siteOrigin: string | undefined, base: string | undefined): string;
+/**
+ * The canonical URL for a page.
+ *
+ * @remarks
+ * With no configured origin the prefix is `""`, so the result is
+ * root-relative (`/api/class/foo`) rather than absent. That matches RSPress's
+ * own documented `base + routePath` fallback and keeps the tag inspectable
+ * under a dev server, where no configured origin could be correct.
+ *
+ * @public
+ */
+declare function canonicalUrl(siteUrl: string, pageRoute: string): string;
+//#endregion
+//#region src/HeadTag.d.ts
+/**
+ * The neutral head-tag vocabulary every adapter renders.
+ *
+ * @remarks
+ * A `HeadTag` is deliberately not a framework element. RSPress renders one
+ * into a frontmatter `head` pair; VitePress renders the same value into a
+ * `transformHead` entry. Keeping the type this dumb is what makes the second
+ * adapter cheap.
+ *
+ * @packageDocumentation
+ */
+/**
+ * One tag destined for a page's `<head>`.
+ *
+ * @public
+ */
+interface HeadTag {
+  readonly tag: "meta" | "link" | "script";
+  readonly attrs: Readonly<Record<string, string>>;
+  /** Element content. Only meaningful for `script`. */
+  readonly body?: string;
+}
+/**
+ * Escape a JSON string so it cannot terminate the `<script>` element that
+ * carries it.
+ *
+ * @remarks
+ * Every string in a JSON-LD graph originates in author-written TSDoc, so a
+ * summary containing the literal `</script>` would close the element early and
+ * inject markup into the page. `JSON.stringify` does not escape it.
+ *
+ * Escaping both angle brackets as `<` / `>` is valid JSON that
+ * parses back to the original characters, so the graph a consumer reads is
+ * unchanged while the element becomes unclosable from inside.
+ *
+ * `&` is escaped for the same reason at a different layer: XHTML parses
+ * script content as ordinary element content, where a bare `&` is a
+ * well-formedness error. An HTML-parsed page tolerates it; an XHTML-served one
+ * does not, and nothing in a docs pipeline guarantees which a consumer serves.
+ *
+ * The escape is idempotent — no escape sequence it emits contains `<`, `>` or
+ * `&` — so a body that arrives already escaped by an upstream serializer
+ * survives a second pass unchanged.
+ *
+ * @public
+ */
+declare function escapeScriptBody(json: string): string;
+/** An Open Graph style `<meta property=… content=…>`. @public */
+declare function meta(property: string, content: string): HeadTag;
+/** A Twitter/standard style `<meta name=… content=…>`. @public */
+declare function metaNamed(name: string, content: string): HeadTag;
+/** A `<link rel=… href=…>`. @public */
+declare function link(rel: string, href: string): HeadTag;
+/** A `<script type="application/ld+json">` carrying an escaped body. @public */
+declare function jsonLd(json: string): HeadTag;
+//#endregion
+//#region src/OpenGraph.d.ts
+/**
+ * Structured Open Graph image metadata (alternative to a plain URL string).
+ *
+ * @public
+ */
+declare const OpenGraphImageMetadata: Schema.Struct<{
+  /** Absolute URL of the image. */
+  readonly url: Schema.String;
+  /** HTTPS URL of the image (for secure contexts). */
+  readonly secureUrl: Schema.optional<Schema.String>;
+  /** MIME type of the image (e.g. `"image/png"`). */
+  readonly type: Schema.optional<Schema.String>;
+  /** Image width in pixels. */
+  readonly width: Schema.optional<Schema.Number>;
+  /** Image height in pixels. */
+  readonly height: Schema.optional<Schema.Number>;
+  /** Alt text for the image. */
+  readonly alt: Schema.optional<Schema.String>;
+}>;
+/** @public */
+type OpenGraphImageMetadata = typeof OpenGraphImageMetadata.Type;
+/**
+ * Open Graph image: either a plain URL string or structured `OpenGraphImageMetadata`.
+ *
+ * @public
+ */
+declare const OpenGraphImageConfig: Schema.Union<readonly [Schema.String, Schema.Struct<{
+  /** Absolute URL of the image. */
+  readonly url: Schema.String;
+  /** HTTPS URL of the image (for secure contexts). */
+  readonly secureUrl: Schema.optional<Schema.String>;
+  /** MIME type of the image (e.g. `"image/png"`). */
+  readonly type: Schema.optional<Schema.String>;
+  /** Image width in pixels. */
+  readonly width: Schema.optional<Schema.Number>;
+  /** Image height in pixels. */
+  readonly height: Schema.optional<Schema.Number>;
+  /** Alt text for the image. */
+  readonly alt: Schema.optional<Schema.String>;
+}>]>;
+/** @public */
+type OpenGraphImageConfig = typeof OpenGraphImageConfig.Type;
+/**
+ * Resolved Open Graph metadata for one documentation page.
+ *
+ * @public
+ */
+declare const OpenGraphMetadata: Schema.Struct<{
+  /** Canonical site base URL. */
+  readonly siteUrl: Schema.String;
+  /** Page route path (e.g. `/api/classes/myclass`). */
+  readonly pageRoute: Schema.String;
+  /** Page description for the `og:description` tag. */
+  readonly description: Schema.String;
+  /** ISO 8601 date string for `article:published_time`. */
+  readonly publishedTime: Schema.String;
+  /** ISO 8601 date string for `article:modified_time`. */
+  readonly modifiedTime: Schema.String;
+  /** Article section label (e.g. `"API"`). */
+  readonly section: Schema.String;
+  /** Article tag keywords. */
+  readonly tags: Schema.mutable<Schema.$Array<Schema.String>>;
+  /** Optional structured image metadata. */
+  readonly ogImage: Schema.optional<Schema.Struct<{
+    /** Absolute URL of the image. */
+    readonly url: Schema.String;
+    /** HTTPS URL of the image (for secure contexts). */
+    readonly secureUrl: Schema.optional<Schema.String>;
+    /** MIME type of the image (e.g. `"image/png"`). */
+    readonly type: Schema.optional<Schema.String>;
+    /** Image width in pixels. */
+    readonly width: Schema.optional<Schema.Number>;
+    /** Image height in pixels. */
+    readonly height: Schema.optional<Schema.Number>;
+    /** Alt text for the image. */
+    readonly alt: Schema.optional<Schema.String>;
+  }>>;
+  /** Open Graph object type (e.g. `"article"`). */
+  readonly ogType: Schema.String;
+}>;
+/** @public */
+type OpenGraphMetadata = typeof OpenGraphMetadata.Type;
+/**
+ * Descriptive alt text for a package's (or one API's) OG image.
+ *
+ * @public
+ */
+declare function ogAltText(packageName: string, apiName?: string): string;
+/**
+ * Assemble the complete Open Graph metadata for one documentation page.
+ *
+ * @public
+ */
+declare function createPageMetadata(options: {
+  siteUrl: string;
+  pageRoute: string;
+  description: string;
+  publishedTime: string;
+  modifiedTime: string;
+  section: string;
+  packageName: string;
+  ogImage?: OpenGraphImageMetadata;
+}): OpenGraphMetadata;
+/**
+ * The Open Graph block for a page.
+ *
+ * @remarks
+ * Each optional image sub-tag is emitted only when the resolved image actually
+ * carries it — an `og:image:width` with no width is a tag a crawler reads as a
+ * declared-but-empty dimension rather than an absent one.
+ *
+ * @public
+ */
+declare function openGraphTags(metadata: OpenGraphMetadata): ReadonlyArray<HeadTag>;
+/**
+ * Twitter card tags derived from the same metadata as the Open Graph block.
+ *
+ * @remarks
+ * Twitter reads most `og:` tags directly, so only what it does not infer is
+ * emitted here. The card type is a function of whether an image exists —
+ * `summary_large_image` with one, `summary` without — because declaring the
+ * large card with no image renders as a broken preview rather than degrading
+ * to the small one.
+ *
+ * Twitter's tags use `name`, not `property`.
+ *
+ * @public
+ */
+declare function twitterTags(metadata: OpenGraphMetadata, site?: string): ReadonlyArray<HeadTag>;
+//#endregion
+//#region src/Seo.d.ts
+/**
+ * Everything {@link headTags} needs about one documentation page.
+ *
+ * @public
+ */
+interface SeoPageInput {
+  /** Site URL prefix, from `deriveSiteUrl`. `""` leaves every URL root-relative. */
+  readonly siteUrl: string;
+  /** Page route path, beginning with `/`. */
+  readonly pageRoute: string;
+  /** Page description, used for both `og:description` and `twitter:description`. */
+  readonly description: string;
+  /** ISO 8601 date string for `article:published_time`. */
+  readonly publishedTime: string;
+  /** ISO 8601 date string for `article:modified_time`. */
+  readonly modifiedTime: string;
+  /** Article section label (e.g. `"Classes"`). */
+  readonly section: string;
+  /** The documented package's npm name. */
+  readonly packageName: string;
+  /** Resolved Open Graph image, when the API declares one. */
+  readonly ogImage?: OpenGraphImageMetadata;
+  /** The `twitter:site` handle, when the site declares one. */
+  readonly twitterSite?: string;
+  /** A serialized JSON-LD graph. Absent until structured data is wired. */
+  readonly structuredData?: string;
+}
+/**
+ * Every `<head>` tag for one documentation page.
+ *
+ * @remarks
+ * The order — canonical link, Open Graph block, Twitter block, then the
+ * JSON-LD script — is fixed. It carries no semantics: a crawler reads the
+ * tags as a set. It is fixed so that a page's emitted head is stable
+ * build-to-build and a diff over generated pages stays readable.
+ *
+ * @public
+ */
+declare function headTags(input: SeoPageInput): ReadonlyArray<HeadTag>;
+//#endregion
+//#region src/StructuredData.d.ts
+/**
+ * Every way {@link derive} can fail, all of them identity problems raised by
+ * `JsonLdDocument.buildResult`.
+ *
+ * @public
+ */
+type StructuredDataError = ConflictingTermError | DuplicateNodeIdError | InvalidNodeIdError;
+/**
+ * The facts about a documented package that every page in it shares.
+ *
+ * @remarks
+ * A value of this shape is derived **once per API** and carried across the
+ * page pipeline. Deriving it per page would build several hundred identical
+ * nodes in a build, and re-run the attribution derivation behind each one.
+ *
+ * @public
+ */
+interface PackageNodeInput {
+  /** Site URL prefix, from `deriveSiteUrl`. `""` leaves every id root-relative. */
+  readonly siteUrl: string;
+  /** The route the package's documentation is mounted at, beginning with `/`. */
+  readonly baseRoute: string;
+  /** The documented package's npm name. */
+  readonly packageName: string;
+  /** The package version, when the manifest carried one. */
+  readonly version?: string;
+  /** The package description, when the manifest carried one. */
+  readonly description?: string;
+  /** Attribution derived from the manifest via {@link attributionFacts}. */
+  readonly attribution: AttributionFacts;
+}
+/**
+ * The facts about one documentation page.
+ *
+ * @public
+ */
+interface PageNodeInput {
+  /** Page route path, beginning with `/`. */
+  readonly pageRoute: string;
+  /** The documented symbol's display name (e.g. `"Pipeline"`). */
+  readonly symbolName: string;
+  /** Page description, reused as both nodes' `description`. */
+  readonly description: string;
+  /** Article section label (e.g. `"Classes"`). */
+  readonly section: string;
+  /** ISO 8601 date string for `datePublished`. */
+  readonly publishedTime: string;
+  /** ISO 8601 date string for `dateModified`. */
+  readonly modifiedTime: string;
+}
+/**
+ * The per-API package facts, resolved once into the nodes every page reuses.
+ *
+ * @remarks
+ * Opaque by intent: build it with {@link packageContext} and carry it, don't
+ * assemble one by hand. The whole reason it exists is that the nodes inside it
+ * are identical on every page of an API, and rebuilding them per page would
+ * mint several hundred copies per build.
+ *
+ * @public
+ */
+interface PackageContext {
+  /** The `@id` every page's nodes reference the package by. */
+  readonly id: string;
+  /** The package node and every person node it credits. */
+  readonly nodes: ReadonlyArray<JsonLdNode>;
+  /** Carried through so page ids resolve against the same prefix. */
+  readonly siteUrl: string;
+  /** Carried through for the symbol node's `assemblyVersion`. */
+  readonly version?: string;
+}
+/**
+ * The `SoftwareSourceCode` node for a documented package, plus the people it
+ * credits.
+ *
+ * @remarks
+ * Note `version`, not `softwareVersion` — the latter reads like the right name
+ * and is defined on `SoftwareApplication`, not here. It would serialize fine
+ * and be silently ignored; the conformance validator is what catches it.
+ *
+ * `license` carries the canonical SPDX page for EVERY license the expression
+ * names — schema.org's `license` accepts an array, and an `AND` expression has
+ * no single answer to give. The URLs come from each catalog entry's own
+ * `referenceUrl`, never from concatenating an id onto
+ * `https://spdx.org/licenses/`: that is the string-building the catalog exists
+ * to prevent, and it is wrong for a `LicenseRef`, which has no such page. A
+ * license outside the catalog drops out of the array rather than appearing as
+ * a fabricated URL.
+ *
+ * @param input - the per-API facts
+ * @returns the reusable context every page in the API derives against
+ *
+ * @public
+ */
+declare function packageContext(input: PackageNodeInput): PackageContext;
+/**
+ * Derive the schema.org graph for one documentation page.
+ *
+ * @remarks
+ * Three linked nodes plus the package's people: a `SoftwareSourceCode` for the
+ * package, a `TechArticle` for the page, and an `APIReference` for the symbol
+ * the page documents. The article `isPartOf` the package and its `mainEntity`
+ * is the symbol, so a crawler reading any one node can reach the other two.
+ *
+ * Serialize the result with `JsonLdDocument.toScriptBody()`, never with
+ * `JSON.stringify(graph.toJsonLd())` — `toScriptBody` is the only serializer
+ * that escapes the sequences that would close the surrounding `<script>`
+ * element, and it is idempotent, so an adapter layering its own escaping over
+ * it is a no-op rather than a double-escape.
+ *
+ * @param pkg - the per-API context from {@link packageContext}
+ * @param page - the per-page facts
+ * @returns the assembled graph, or the identity failure that stopped it
+ *
+ * @public
+ */
+declare function derive(pkg: PackageContext, page: PageNodeInput): Result.Result<JsonLdDocument, StructuredDataError>;
+/**
+ * {@link derive}, serialized to the text an adapter embeds in a `<script>`.
+ *
+ * @remarks
+ * The convenience the adapter actually wants: a page's structured data as a
+ * string. Callers that need the graph itself — a conformance check in a test,
+ * say — use {@link derive}.
+ *
+ * @param pkg - the per-API context from {@link packageContext}
+ * @param page - the per-page facts
+ * @returns the script body, or the identity failure
+ *
+ * @public
+ */
+declare function deriveScriptBody(pkg: PackageContext, page: PageNodeInput): Result.Result<string, StructuredDataError>;
+//#endregion
+export { type AttributionFacts, type HeadTag, OpenGraphImageConfig, OpenGraphImageMetadata, OpenGraphMetadata, type PackageContext, type PackageNodeInput, type PageNodeInput, type SeoPageInput, type StructuredDataError, attributionFacts, canonicalUrl, createPageMetadata, derive, deriveScriptBody, deriveSiteUrl, escapeScriptBody, headTags, imageMimeType, jsonLd, link, meta, metaNamed, ogAltText, openGraphTags, packageContext, resolveUrl, twitterTags };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,8 @@
+import { attributionFacts } from "./Attribution.js";
+import { canonicalUrl, deriveSiteUrl, imageMimeType, resolveUrl } from "./Canonical.js";
+import { escapeScriptBody, jsonLd, link, meta, metaNamed } from "./HeadTag.js";
+import { OpenGraphImageConfig, OpenGraphImageMetadata, OpenGraphMetadata, createPageMetadata, ogAltText, openGraphTags, twitterTags } from "./OpenGraph.js";
+import { headTags } from "./Seo.js";
+import { derive, deriveScriptBody, packageContext } from "./StructuredData.js";
+
+export { OpenGraphImageConfig, OpenGraphImageMetadata, OpenGraphMetadata, attributionFacts, canonicalUrl, createPageMetadata, derive, deriveScriptBody, deriveSiteUrl, escapeScriptBody, headTags, imageMimeType, jsonLd, link, meta, metaNamed, ogAltText, openGraphTags, packageContext, resolveUrl, twitterTags };

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@tsdoctor/seo",
+	"version": "0.1.0",
+	"private": false,
+	"description": "Framework-neutral head metadata for static TypeScript API documentation: schema.org JSON-LD, Open Graph and Twitter card vocabulary, canonical URLs, and package attribution derived from an api.json model plus its manifest.",
+	"keywords": [
+		"seo",
+		"schema.org",
+		"json-ld",
+		"open-graph",
+		"documentation",
+		"effect"
+	],
+	"homepage": "https://github.com/spencerbeggs/tsdoctor#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/tsdoctor/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/tsdoctor.git",
+		"directory": "packages/seo"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js",
+			"default": "./index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"peerDependencies": {
+		"@effected/package-json": "^0.13.0",
+		"@effected/schema-org": "^0.1.0",
+		"@effected/spdx": "^0.5.0",
+		"effect": "4.0.0-rc.109"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
+}

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.59.0"
+    }
+  ]
+}