@absolutejs/artifacts 0.0.1

package/dist/manifest.json

@@ -0,0 +1,100 @@
+{
+	"contract": 1,
+	"identity": {
+		"accent": "#8b5cf6",
+		"category": "ai",
+		"description": "Typed, versioned artifacts for AI products: define structured kinds once, then compose storage, revisions, rendering, publishing, and agent tools without coupling the contract to a database or hosting layer.",
+		"docsUrl": "https://github.com/absolutejs/artifacts",
+		"name": "@absolutejs/artifacts",
+		"tagline": "Give everything your AI makes a real lifecycle."
+	},
+	"settings": {
+		"type": "object",
+		"properties": {}
+	},
+	"slots": {
+		"service": {
+			"configPath": "$self",
+			"contract": "artifacts/service",
+			"description": "The host-configured artifact service",
+			"known": [],
+			"required": true
+		}
+	},
+	"wiring": [
+		{
+			"description": "Define structured artifact kinds, provide a store, and create the lifecycle service. Add a publisher only when your host supports public access.",
+			"id": "default",
+			"server": {
+				"code": "const artifactRegistry = defineArtifactRegistry({\n\tpage: {\n\t\tcapabilities: ['archive', 'edit', 'preview', 'publish'],\n\t\tcontent: Type.Object({ blocks: Type.Array(Type.Unknown()) }),\n\t\tlabel: 'Page'\n\t}\n});\n\nconst artifactStore = createMemoryArtifactStore();\nconst artifactService = createArtifactService({\n\tregistry: artifactRegistry,\n\tstore: artifactStore\n});",
+				"imports": [
+					{
+						"from": "@absolutejs/artifacts",
+						"names": [
+							"createArtifactService",
+							"createMemoryArtifactStore",
+							"defineArtifactRegistry"
+						]
+					},
+					{
+						"from": "@sinclair/typebox",
+						"names": [
+							"Type"
+						]
+					}
+				],
+				"placement": "module-scope"
+			},
+			"title": "Define artifact kinds and lifecycle"
+		}
+	],
+	"tools": {
+		"artifact_get": {
+			"annotations": {
+				"readOnlyHint": true
+			},
+			"description": "Open one artifact owned by a user.",
+			"input": {
+				"type": "object",
+				"required": [
+					"artifactId",
+					"ownerId"
+				],
+				"properties": {
+					"artifactId": {
+						"minLength": 1,
+						"type": "string"
+					},
+					"ownerId": {
+						"minLength": 1,
+						"type": "string"
+					}
+				}
+			},
+			"kind": "runtime"
+		},
+		"artifact_list": {
+			"annotations": {
+				"readOnlyHint": true
+			},
+			"description": "List artifacts owned by a user.",
+			"input": {
+				"type": "object",
+				"required": [
+					"ownerId"
+				],
+				"properties": {
+					"kind": {
+						"minLength": 1,
+						"type": "string"
+					},
+					"ownerId": {
+						"minLength": 1,
+						"type": "string"
+					}
+				}
+			},
+			"kind": "runtime"
+		}
+	}
+}

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `@absolutejs/artifacts` — the typed lifecycle for things an AI makes.
+ *
+ * Hosts define artifact kinds with structured content schemas, then compose a
+ * storage adapter, optional publisher, renderers, and agent tools. The package
+ * owns validation, revisions, lifecycle semantics, and contracts; the host
+ * retains authorization, persistence, URLs, UI, and delivery policy.
+ */
+export { defineArtifactRegistry, type ArtifactContent, type ArtifactKindDefinition, type ArtifactKindDefinitions, type ArtifactRegistry, } from "./registry";
+export { createArtifactRendererRegistry, type ArtifactRenderer, type ArtifactRendererRegistry, type ArtifactRenderResult, } from "./renderers";
+export { createArtifactService, type ArtifactPublisher, type ArtifactService, type ArtifactServiceOptions, } from "./service";
+export { createMemoryArtifactStore, type ArtifactStore } from "./store";
+export { createArtifactTools, type ArtifactToolDefinition, type ArtifactToolMap, type ArtifactToolOptions, } from "./tools";
+export { ARTIFACT_STATUSES, ArtifactError, type ArtifactCapability, type ArtifactCreateInput, type ArtifactErrorCode, type ArtifactListQuery, type ArtifactProvenance, type ArtifactPublication, type ArtifactRecord, type ArtifactStatus, type ArtifactUpdateInput, } from "./types";

package/dist/src/manifest.d.ts

@@ -0,0 +1,9 @@
+export declare const manifest: import("@absolutejs/manifest").PackageManifest<Record<string, never>, {
+    archive: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
+    create: (ownerId: string, input: import("./types").ArtifactCreateInput) => Promise<import("./types").ArtifactRecord>;
+    get: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
+    list: (ownerId: string, query?: import("./types").ArtifactListQuery) => Promise<import("./types").ArtifactRecord[]>;
+    publish: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
+    unpublish: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
+    update: (ownerId: string, artifactId: string, input: import("./types").ArtifactUpdateInput) => Promise<import("./types").ArtifactRecord>;
+}>;

package/dist/src/registry.d.ts

@@ -0,0 +1,17 @@
+import type { Static, TSchema } from "@sinclair/typebox";
+import { type ArtifactCapability } from "./types";
+export type ArtifactKindDefinition<TContent extends TSchema = TSchema> = {
+    capabilities?: ArtifactCapability[];
+    content: TContent;
+    description?: string;
+    label: string;
+    schemaVersion?: number;
+};
+export type ArtifactKindDefinitions = Record<string, ArtifactKindDefinition<TSchema>>;
+export type ArtifactContent<TDefinitions extends ArtifactKindDefinitions, TKind extends keyof TDefinitions> = TDefinitions[TKind] extends ArtifactKindDefinition<infer TSchemaValue> ? Static<TSchemaValue> : never;
+export type ArtifactRegistry<TDefinitions extends ArtifactKindDefinitions> = {
+    definitions: TDefinitions;
+    kindNames: Array<keyof TDefinitions & string>;
+    parse<TKind extends keyof TDefinitions & string>(kind: TKind, content: unknown): ArtifactContent<TDefinitions, TKind>;
+};
+export declare const defineArtifactRegistry: <const TDefinitions extends ArtifactKindDefinitions>(definitions: TDefinitions) => ArtifactRegistry<TDefinitions>;

package/dist/src/renderers.d.ts

@@ -0,0 +1,17 @@
+import { type ArtifactRecord } from "./types";
+export type ArtifactRenderResult = {
+    body: Uint8Array | string;
+    filename?: string;
+    mediaType: string;
+};
+export type ArtifactRenderer = {
+    format: string;
+    kind: string;
+    render(artifact: ArtifactRecord): Promise<ArtifactRenderResult>;
+};
+export declare const createArtifactRendererRegistry: (initial?: ArtifactRenderer[]) => {
+    formatsFor: (kind: string) => string[];
+    register: (renderer: ArtifactRenderer) => void;
+    render: (artifact: ArtifactRecord, format: string) => Promise<ArtifactRenderResult>;
+};
+export type ArtifactRendererRegistry = ReturnType<typeof createArtifactRendererRegistry>;

package/dist/src/service.d.ts

@@ -0,0 +1,31 @@
+import type { ArtifactKindDefinitions, ArtifactRegistry } from "./registry";
+import type { ArtifactStore } from "./store";
+import { type ArtifactCreateInput, type ArtifactListQuery, type ArtifactRecord, type ArtifactUpdateInput } from "./types";
+export type ArtifactPublisher = {
+    publish(artifact: ArtifactRecord, options: {
+        idempotencyKey: string;
+    }): Promise<{
+        id: string;
+        url: string;
+    }>;
+    unpublish(artifact: ArtifactRecord, options: {
+        idempotencyKey: string;
+    }): Promise<void>;
+};
+export type ArtifactServiceOptions<TDefinitions extends ArtifactKindDefinitions = ArtifactKindDefinitions> = {
+    clock?: () => Date;
+    idFactory?: () => string;
+    publisher?: ArtifactPublisher;
+    registry: ArtifactRegistry<TDefinitions>;
+    store: ArtifactStore;
+};
+export type ArtifactService = ReturnType<typeof createArtifactService>;
+export declare const createArtifactService: <TDefinitions extends ArtifactKindDefinitions>(options: ArtifactServiceOptions<TDefinitions>) => {
+    archive: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
+    create: (ownerId: string, input: ArtifactCreateInput) => Promise<ArtifactRecord>;
+    get: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
+    list: (ownerId: string, query?: ArtifactListQuery) => Promise<ArtifactRecord[]>;
+    publish: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
+    unpublish: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
+    update: (ownerId: string, artifactId: string, input: ArtifactUpdateInput) => Promise<ArtifactRecord>;
+};

package/dist/src/store.d.ts

@@ -0,0 +1,8 @@
+import type { ArtifactListQuery, ArtifactRecord } from "./types";
+export type ArtifactStore = {
+    create(record: ArtifactRecord): Promise<void>;
+    get(ownerId: string, artifactId: string): Promise<ArtifactRecord | null>;
+    list(ownerId: string, query?: ArtifactListQuery): Promise<ArtifactRecord[]>;
+    save(record: ArtifactRecord, expectedRevision: number): Promise<boolean>;
+};
+export declare const createMemoryArtifactStore: (initial?: ArtifactRecord[]) => ArtifactStore;

package/dist/src/tools.d.ts

@@ -0,0 +1,17 @@
+import { type TSchema } from "@sinclair/typebox";
+import type { ArtifactService } from "./service";
+export type ArtifactToolDefinition = {
+    annotations?: {
+        readOnlyHint?: boolean;
+    };
+    description: string;
+    handler(input: unknown): Promise<string> | string;
+    input: TSchema;
+};
+export type ArtifactToolMap = Record<string, ArtifactToolDefinition>;
+export type ArtifactToolOptions = {
+    createdBy: string;
+    ownerId: string;
+    service: ArtifactService;
+};
+export declare const createArtifactTools: (options: ArtifactToolOptions) => ArtifactToolMap;

package/dist/src/types.d.ts

@@ -0,0 +1,55 @@
+export declare const ARTIFACT_STATUSES: readonly ["draft", "published", "archived"];
+export type ArtifactStatus = (typeof ARTIFACT_STATUSES)[number];
+export type ArtifactCapability = "archive" | "edit" | "export" | "preview" | "publish" | "refine";
+export type ArtifactProvenance = {
+    model?: string;
+    sourceIds?: string[];
+    tool?: string;
+    traceId?: string;
+};
+export type ArtifactPublication = {
+    id: string;
+    publishedAt: string;
+    url: string;
+};
+export type ArtifactRecord<TContent = unknown> = {
+    capabilities: ArtifactCapability[];
+    content: TContent;
+    createdAt: string;
+    createdBy: string;
+    id: string;
+    kind: string;
+    metadata: Record<string, unknown>;
+    ownerId: string;
+    provenance?: ArtifactProvenance;
+    publication?: ArtifactPublication;
+    revision: number;
+    schemaVersion: number;
+    status: ArtifactStatus;
+    title: string;
+    updatedAt: string;
+};
+export type ArtifactListQuery = {
+    kind?: string;
+    limit?: number;
+    status?: ArtifactStatus;
+};
+export type ArtifactCreateInput = {
+    content: unknown;
+    createdBy: string;
+    kind: string;
+    metadata?: Record<string, unknown>;
+    provenance?: ArtifactProvenance;
+    title: string;
+};
+export type ArtifactUpdateInput = {
+    content?: unknown;
+    expectedRevision?: number;
+    metadata?: Record<string, unknown>;
+    title?: string;
+};
+export type ArtifactErrorCode = "conflict" | "invalid_content" | "not_found" | "publisher_unavailable" | "renderer_unavailable" | "unsupported_capability" | "unknown_kind";
+export declare class ArtifactError extends Error {
+    readonly code: ArtifactErrorCode;
+    constructor(code: ArtifactErrorCode, message: string);
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@absolutejs/artifacts",
+  "version": "0.0.1",
+  "description": "Typed, versioned artifacts for AI products — schemas, lifecycle, storage, rendering, publishing, revisions, and agent tools without prescribing a database or host.",
+  "author": "Alex Kahn",
+  "license": "BUSL-1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/absolutejs/artifacts.git"
+  },
+  "homepage": "https://github.com/absolutejs/artifacts",
+  "bugs": {
+    "url": "https://github.com/absolutejs/artifacts/issues"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build src/index.ts src/manifest.ts --outdir dist --root ./src --target=bun --external @sinclair/typebox --external @sinclair/typebox/value && tsc --emitDeclarationOnly --project tsconfig.json && absolute-manifest emit",
+    "format": "prettier --write \"./**/*.{ts,json,md}\"",
+    "release": "bun run format && bun run test && bun run build && bun publish",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit --project tsconfig.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "absolutejs": {
+    "manifestContract": 1
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/src/manifest.d.ts",
+      "import": "./dist/manifest.js",
+      "default": "./dist/manifest.js"
+    },
+    "./manifest.json": "./dist/manifest.json"
+  },
+  "dependencies": {
+    "@absolutejs/manifest": "^0.1.0",
+    "@sinclair/typebox": "^0.34.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "prettier": "3.5.3",
+    "typescript": "5.8.3"
+  }
+}