constructa-schema 0.0.1 → 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Constructa contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -3,3 +3,21 @@
 Portable generator definitions, validation schemas, and related types shared by every Constructa interface.
 
 Planned areas include definition versioning, primitive and composite definitions, validation results, and safe serialization. This package must remain independent of execution, UI, network, and persistence concerns.
+
+## Portable data constraint
+
+Portable generator definitions are JSON-only data. Supported values are strings, booleans, `null`, finite numbers other than negative zero, arrays, and plain object records whose properties are all JSON values.
+
+Omit optional data by leaving the property out. `undefined` is not a portable value, including in object properties or array items. Values that JSON would coerce, execute, or silently omit are rejected, including functions, symbols, bigints, `NaN`, infinities, cyclic objects, sparse arrays, custom `toJSON` behavior, class instances, maps, sets, dates, accessors, symbol keys, and non-enumerable properties.
+
+Use `isJsonValue`, `assertJsonValue`, or `findJsonValueError` to enforce this constraint before later schema-specific validation.
+
+## Schema version
+
+Complete portable definitions must include `schemaVersion: 1`. `CURRENT_SCHEMA_VERSION` identifies the version emitted by current Constructa tooling, and `SUPPORTED_SCHEMA_VERSIONS` lists the versions accepted by this package.
+
+Use `isSchemaVersion`, `assertSchemaVersion`, `isVersionedDefinition`, `assertVersionedDefinition`, `findSchemaVersionValueFailure`, or `findSchemaVersionFailure` to reject missing or unsupported version markers with structured failures.
+
+## Dependency boundary
+
+This is the bottom of the domain dependency graph and has no Constructa runtime dependencies. In particular, it must not import core, generators, exporters, the SDK, applications, UI, environment, persistence, or transport code.

package/dist/index.d.ts

@@ -1 +1,43 @@
-export {}
+//#region src/index.d.ts
+type JsonPrimitive = boolean | null | number | string;
+type JsonValue = JsonArray | JsonObject | JsonPrimitive;
+type JsonArray = readonly JsonValue[];
+type JsonObject = {
+  readonly [key: string]: JsonValue;
+};
+declare const CURRENT_SCHEMA_VERSION = 1;
+declare const SUPPORTED_SCHEMA_VERSIONS: readonly [1];
+type SchemaVersion = (typeof SUPPORTED_SCHEMA_VERSIONS)[number];
+type VersionedDefinition = JsonObject & {
+  readonly schemaVersion: SchemaVersion;
+};
+type SchemaVersionFailureCode = "schema_version_missing" | "schema_version_unsupported";
+type SchemaVersionFailure = {
+  readonly code: SchemaVersionFailureCode;
+  readonly message: string;
+  readonly path: string;
+  readonly severity: "error";
+  readonly supportedVersions: readonly SchemaVersion[];
+};
+declare class JsonValueError extends TypeError {
+  constructor(path: string, reason: string);
+}
+declare class SchemaVersionError extends TypeError {
+  readonly failure: SchemaVersionFailure;
+  constructor(failure: SchemaVersionFailure);
+}
+declare function isJsonValue(value: unknown): value is JsonValue;
+declare function isSchemaVersion(value: unknown): value is SchemaVersion;
+declare function isVersionedDefinition(value: unknown): value is VersionedDefinition;
+declare function assertJsonValue(value: unknown, path?: string): asserts value is JsonValue;
+declare function assertSchemaVersion(value: unknown, path?: string): asserts value is SchemaVersion;
+declare function assertVersionedDefinition(value: unknown, path?: string): asserts value is VersionedDefinition;
+declare function findJsonValueError(value: unknown, path?: string): {
+  path: string;
+  reason: string;
+} | undefined;
+declare function findSchemaVersionFailure(value: unknown, path?: string): SchemaVersionFailure | undefined;
+declare function findSchemaVersionValueFailure(value: unknown, path?: string): SchemaVersionFailure | undefined;
+//#endregion
+export { CURRENT_SCHEMA_VERSION, JsonArray, JsonObject, JsonPrimitive, JsonValue, JsonValueError, SUPPORTED_SCHEMA_VERSIONS, SchemaVersion, SchemaVersionError, SchemaVersionFailure, SchemaVersionFailureCode, VersionedDefinition, assertJsonValue, assertSchemaVersion, assertVersionedDefinition, findJsonValueError, findSchemaVersionFailure, findSchemaVersionValueFailure, isJsonValue, isSchemaVersion, isVersionedDefinition };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";KAAY;KAEA,YAAY,YAAY,aAAa;KAErC,qBAAqB;KAErB;YACA,cAAc;;cAGb;cAEA;KAED,wBAAwB;KAExB,sBAAsB;WACvB,eAAe;;KAGd;KAIA;WACD,MAAM;WACN;WACA;WACA;WACA,4BAA4B;;cAG1B,uBAAuB;EACtB,YAAA,cAAc;;cAMf,2BAA2B;WAC7B,SAAS;EAEN,YAAA,SAAS;;iBAOP,YAAY,iBAAiB,SAAS;iBAItC,gBAAgB,iBAAiB,SAAS;iBAI1C,sBACd,iBACC,SAAS;iBAQI,gBACd,gBACA,wBACS,SAAS;iBAQJ,oBACd,gBACA,wBACS,SAAS;iBAQJ,0BACd,gBACA,wBACS,SAAS;iBAUJ,mBACd,gBACA;EACG;EAAc;;iBAIH,yBACd,gBACA,gBACC;iBAaa,8BACd,gBACA,gBACC"}

package/dist/index.js

@@ -0,0 +1,165 @@
+//#region src/index.ts
+const CURRENT_SCHEMA_VERSION = 1;
+const SUPPORTED_SCHEMA_VERSIONS = [1];
+var JsonValueError = class extends TypeError {
+	constructor(path, reason) {
+		super(`${path}: ${reason}`);
+		this.name = "JsonValueError";
+	}
+};
+var SchemaVersionError = class extends TypeError {
+	failure;
+	constructor(failure) {
+		super(`${failure.path}: ${failure.message}`);
+		this.name = "SchemaVersionError";
+		this.failure = failure;
+	}
+};
+function isJsonValue(value) {
+	return findJsonValueError(value) === void 0;
+}
+function isSchemaVersion(value) {
+	return value === 1;
+}
+function isVersionedDefinition(value) {
+	return findSchemaVersionFailure(value) === void 0 && isJsonRecord(value) && isJsonValue(value);
+}
+function assertJsonValue(value, path = "$") {
+	const error = findJsonValueError(value, path);
+	if (error !== void 0) throw new JsonValueError(error.path, error.reason);
+}
+function assertSchemaVersion(value, path = "$.schemaVersion") {
+	const failure = findSchemaVersionValueFailure(value, path);
+	if (failure !== void 0) throw new SchemaVersionError(failure);
+}
+function assertVersionedDefinition(value, path = "$") {
+	const failure = findSchemaVersionFailure(value, path);
+	if (failure !== void 0) throw new SchemaVersionError(failure);
+	assertJsonValue(value, path);
+}
+function findJsonValueError(value, path = "$") {
+	return findJsonValueErrorInternal(value, path, /* @__PURE__ */ new Set());
+}
+function findSchemaVersionFailure(value, path = "$") {
+	if (!isJsonRecord(value) || !Object.hasOwn(value, "schemaVersion")) return createSchemaVersionFailure("schema_version_missing", { path: appendPathSegment(path, "schemaVersion") });
+	return findSchemaVersionValueFailure(value.schemaVersion, appendPathSegment(path, "schemaVersion"));
+}
+function findSchemaVersionValueFailure(value, path = "$.schemaVersion") {
+	if (isSchemaVersion(value)) return;
+	return createSchemaVersionFailure("schema_version_unsupported", { path });
+}
+function findJsonValueErrorInternal(value, path, ancestors) {
+	switch (typeof value) {
+		case "boolean":
+		case "string": return;
+		case "number":
+			if (!Number.isFinite(value)) return {
+				path,
+				reason: "number must be finite"
+			};
+			if (Object.is(value, -0)) return {
+				path,
+				reason: "number must not be negative zero"
+			};
+			return;
+		case "object":
+			if (value === null) return;
+			return findJsonObjectError(value, path, ancestors);
+		case "bigint":
+		case "function":
+		case "symbol":
+		case "undefined": return {
+			path,
+			reason: `${typeof value} is not JSON-compatible`
+		};
+	}
+}
+function createSchemaVersionFailure(code, options) {
+	return {
+		code,
+		message: code === "schema_version_missing" ? `schemaVersion is required and must be 1` : `schemaVersion must be 1`,
+		path: options.path,
+		severity: "error",
+		supportedVersions: SUPPORTED_SCHEMA_VERSIONS
+	};
+}
+function appendPathSegment(path, segment) {
+	return path === "$" ? `$.${segment}` : `${path}.${segment}`;
+}
+function isJsonRecord(value) {
+	const prototype = typeof value === "object" && value !== null ? Object.getPrototypeOf(value) : void 0;
+	return typeof value === "object" && value !== null && !Array.isArray(value) && (prototype === null || prototype === Object.prototype);
+}
+function findJsonObjectError(value, path, ancestors) {
+	if (ancestors.has(value)) return {
+		path,
+		reason: "cyclic objects are not JSON-compatible"
+	};
+	if (hasCallableToJson(value)) return {
+		path,
+		reason: "objects with toJSON behavior are not portable"
+	};
+	ancestors.add(value);
+	const error = Array.isArray(value) ? findJsonArrayError(value, path, ancestors) : findJsonRecordError(value, path, ancestors);
+	ancestors.delete(value);
+	return error;
+}
+function hasCallableToJson(value) {
+	return "toJSON" in value && typeof value.toJSON === "function";
+}
+function findJsonArrayError(value, path, ancestors) {
+	const extraProperty = Object.keys(value).find((key) => !isArrayIndexKey(key));
+	if (extraProperty !== void 0) return {
+		path: `${path}.${extraProperty}`,
+		reason: "array object properties would be omitted from JSON"
+	};
+	const ownPropertyError = findUnsupportedOwnProperty(value, path, ["length"]);
+	if (ownPropertyError !== void 0) return ownPropertyError;
+	for (let index = 0; index < value.length; index += 1) {
+		if (!(index in value)) return {
+			path: `${path}[${index}]`,
+			reason: "sparse array slots are not JSON-compatible"
+		};
+		const itemError = findJsonValueErrorInternal(value[index], `${path}[${index}]`, ancestors);
+		if (itemError !== void 0) return itemError;
+	}
+}
+function isArrayIndexKey(key) {
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
+}
+function findJsonRecordError(value, path, ancestors) {
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype) return {
+		path,
+		reason: "object must be a plain JSON record"
+	};
+	const ownPropertyError = findUnsupportedOwnProperty(value, path);
+	if (ownPropertyError !== void 0) return ownPropertyError;
+	for (const key of Object.keys(value)) {
+		const itemError = findJsonValueErrorInternal(value[key], `${path}.${key}`, ancestors);
+		if (itemError !== void 0) return itemError;
+	}
+}
+function findUnsupportedOwnProperty(value, path, allowedNonEnumerableProperties = []) {
+	if (Object.getOwnPropertySymbols(value).length > 0) return {
+		path,
+		reason: "symbol keys are not JSON-compatible"
+	};
+	const allowedNonEnumerable = new Set(allowedNonEnumerableProperties);
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	for (const [key, descriptor] of Object.entries(descriptors)) {
+		if ("get" in descriptor || "set" in descriptor) return {
+			path: `${path}.${key}`,
+			reason: "accessor properties are not portable JSON data"
+		};
+		if (!descriptor.enumerable && !allowedNonEnumerable.has(key)) return {
+			path: `${path}.${key}`,
+			reason: "non-enumerable properties would be omitted from JSON"
+		};
+	}
+}
+//#endregion
+export { CURRENT_SCHEMA_VERSION, JsonValueError, SUPPORTED_SCHEMA_VERSIONS, SchemaVersionError, assertJsonValue, assertSchemaVersion, assertVersionedDefinition, findJsonValueError, findSchemaVersionFailure, findSchemaVersionValueFailure, isJsonValue, isSchemaVersion, isVersionedDefinition };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export type JsonPrimitive = boolean | null | number | string;\n\nexport type JsonValue = JsonArray | JsonObject | JsonPrimitive;\n\nexport type JsonArray = readonly JsonValue[];\n\nexport type JsonObject = {\n  readonly [key: string]: JsonValue;\n};\n\nexport const CURRENT_SCHEMA_VERSION = 1;\n\nexport const SUPPORTED_SCHEMA_VERSIONS = [CURRENT_SCHEMA_VERSION] as const;\n\nexport type SchemaVersion = (typeof SUPPORTED_SCHEMA_VERSIONS)[number];\n\nexport type VersionedDefinition = JsonObject & {\n  readonly schemaVersion: SchemaVersion;\n};\n\nexport type SchemaVersionFailureCode =\n  | \"schema_version_missing\"\n  | \"schema_version_unsupported\";\n\nexport type SchemaVersionFailure = {\n  readonly code: SchemaVersionFailureCode;\n  readonly message: string;\n  readonly path: string;\n  readonly severity: \"error\";\n  readonly supportedVersions: readonly SchemaVersion[];\n};\n\nexport class JsonValueError extends TypeError {\n  constructor(path: string, reason: string) {\n    super(`${path}: ${reason}`);\n    this.name = \"JsonValueError\";\n  }\n}\n\nexport class SchemaVersionError extends TypeError {\n  readonly failure: SchemaVersionFailure;\n\n  constructor(failure: SchemaVersionFailure) {\n    super(`${failure.path}: ${failure.message}`);\n    this.name = \"SchemaVersionError\";\n    this.failure = failure;\n  }\n}\n\nexport function isJsonValue(value: unknown): value is JsonValue {\n  return findJsonValueError(value) === undefined;\n}\n\nexport function isSchemaVersion(value: unknown): value is SchemaVersion {\n  return value === CURRENT_SCHEMA_VERSION;\n}\n\nexport function isVersionedDefinition(\n  value: unknown,\n): value is VersionedDefinition {\n  return (\n    findSchemaVersionFailure(value) === undefined &&\n    isJsonRecord(value) &&\n    isJsonValue(value)\n  );\n}\n\nexport function assertJsonValue(\n  value: unknown,\n  path = \"$\",\n): asserts value is JsonValue {\n  const error = findJsonValueError(value, path);\n\n  if (error !== undefined) {\n    throw new JsonValueError(error.path, error.reason);\n  }\n}\n\nexport function assertSchemaVersion(\n  value: unknown,\n  path = \"$.schemaVersion\",\n): asserts value is SchemaVersion {\n  const failure = findSchemaVersionValueFailure(value, path);\n\n  if (failure !== undefined) {\n    throw new SchemaVersionError(failure);\n  }\n}\n\nexport function assertVersionedDefinition(\n  value: unknown,\n  path = \"$\",\n): asserts value is VersionedDefinition {\n  const failure = findSchemaVersionFailure(value, path);\n\n  if (failure !== undefined) {\n    throw new SchemaVersionError(failure);\n  }\n\n  assertJsonValue(value, path);\n}\n\nexport function findJsonValueError(\n  value: unknown,\n  path = \"$\",\n): { path: string; reason: string } | undefined {\n  return findJsonValueErrorInternal(value, path, new Set());\n}\n\nexport function findSchemaVersionFailure(\n  value: unknown,\n  path = \"$\",\n): SchemaVersionFailure | undefined {\n  if (!isJsonRecord(value) || !Object.hasOwn(value, \"schemaVersion\")) {\n    return createSchemaVersionFailure(\"schema_version_missing\", {\n      path: appendPathSegment(path, \"schemaVersion\"),\n    });\n  }\n\n  return findSchemaVersionValueFailure(\n    value.schemaVersion,\n    appendPathSegment(path, \"schemaVersion\"),\n  );\n}\n\nexport function findSchemaVersionValueFailure(\n  value: unknown,\n  path = \"$.schemaVersion\",\n): SchemaVersionFailure | undefined {\n  if (isSchemaVersion(value)) {\n    return undefined;\n  }\n\n  return createSchemaVersionFailure(\"schema_version_unsupported\", { path });\n}\n\nfunction findJsonValueErrorInternal(\n  value: unknown,\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  switch (typeof value) {\n    case \"boolean\":\n    case \"string\":\n      return undefined;\n    case \"number\":\n      if (!Number.isFinite(value)) {\n        return { path, reason: \"number must be finite\" };\n      }\n      if (Object.is(value, -0)) {\n        return { path, reason: \"number must not be negative zero\" };\n      }\n      return undefined;\n    case \"object\":\n      if (value === null) {\n        return undefined;\n      }\n      return findJsonObjectError(value, path, ancestors);\n    case \"bigint\":\n    case \"function\":\n    case \"symbol\":\n    case \"undefined\":\n      return { path, reason: `${typeof value} is not JSON-compatible` };\n  }\n}\n\nfunction createSchemaVersionFailure(\n  code: SchemaVersionFailureCode,\n  options: { readonly path: string },\n): SchemaVersionFailure {\n  return {\n    code,\n    message:\n      code === \"schema_version_missing\"\n        ? `schemaVersion is required and must be ${CURRENT_SCHEMA_VERSION}`\n        : `schemaVersion must be ${CURRENT_SCHEMA_VERSION}`,\n    path: options.path,\n    severity: \"error\",\n    supportedVersions: SUPPORTED_SCHEMA_VERSIONS,\n  };\n}\n\nfunction appendPathSegment(path: string, segment: string) {\n  return path === \"$\" ? `$.${segment}` : `${path}.${segment}`;\n}\n\nfunction isJsonRecord(value: unknown): value is Record<string, unknown> {\n  const prototype =\n    typeof value === \"object\" && value !== null\n      ? Object.getPrototypeOf(value)\n      : undefined;\n\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    (prototype === null || prototype === Object.prototype)\n  );\n}\n\nfunction findJsonObjectError(\n  value: object,\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  if (ancestors.has(value)) {\n    return { path, reason: \"cyclic objects are not JSON-compatible\" };\n  }\n\n  if (hasCallableToJson(value)) {\n    return { path, reason: \"objects with toJSON behavior are not portable\" };\n  }\n\n  ancestors.add(value);\n  const error = Array.isArray(value)\n    ? findJsonArrayError(value, path, ancestors)\n    : findJsonRecordError(value, path, ancestors);\n  ancestors.delete(value);\n\n  return error;\n}\n\nfunction hasCallableToJson(value: object) {\n  return (\n    \"toJSON\" in value &&\n    typeof (value as { readonly toJSON?: unknown }).toJSON === \"function\"\n  );\n}\n\nfunction findJsonArrayError(\n  value: readonly unknown[],\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  const extraProperty = Object.keys(value).find((key) => !isArrayIndexKey(key));\n\n  if (extraProperty !== undefined) {\n    return {\n      path: `${path}.${extraProperty}`,\n      reason: \"array object properties would be omitted from JSON\",\n    };\n  }\n\n  const ownPropertyError = findUnsupportedOwnProperty(value, path, [\"length\"]);\n\n  if (ownPropertyError !== undefined) {\n    return ownPropertyError;\n  }\n\n  for (let index = 0; index < value.length; index += 1) {\n    if (!(index in value)) {\n      return {\n        path: `${path}[${index}]`,\n        reason: \"sparse array slots are not JSON-compatible\",\n      };\n    }\n\n    const itemError = findJsonValueErrorInternal(\n      value[index],\n      `${path}[${index}]`,\n      ancestors,\n    );\n\n    if (itemError !== undefined) {\n      return itemError;\n    }\n  }\n\n  return undefined;\n}\n\nfunction isArrayIndexKey(key: string) {\n  const index = Number(key);\n\n  return (\n    Number.isInteger(index) &&\n    index >= 0 &&\n    index < 2 ** 32 - 1 &&\n    String(index) === key\n  );\n}\n\nfunction findJsonRecordError(\n  value: object,\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  const prototype = Object.getPrototypeOf(value);\n\n  if (prototype !== null && prototype !== Object.prototype) {\n    return { path, reason: \"object must be a plain JSON record\" };\n  }\n\n  const ownPropertyError = findUnsupportedOwnProperty(value, path);\n\n  if (ownPropertyError !== undefined) {\n    return ownPropertyError;\n  }\n\n  for (const key of Object.keys(value)) {\n    const itemError = findJsonValueErrorInternal(\n      (value as Record<string, unknown>)[key],\n      `${path}.${key}`,\n      ancestors,\n    );\n\n    if (itemError !== undefined) {\n      return itemError;\n    }\n  }\n\n  return undefined;\n}\n\nfunction findUnsupportedOwnProperty(\n  value: object,\n  path: string,\n  allowedNonEnumerableProperties: readonly string[] = [],\n): { path: string; reason: string } | undefined {\n  if (Object.getOwnPropertySymbols(value).length > 0) {\n    return { path, reason: \"symbol keys are not JSON-compatible\" };\n  }\n\n  const allowedNonEnumerable = new Set(allowedNonEnumerableProperties);\n  const descriptors = Object.getOwnPropertyDescriptors(value);\n\n  for (const [key, descriptor] of Object.entries(descriptors)) {\n    if (\"get\" in descriptor || \"set\" in descriptor) {\n      return {\n        path: `${path}.${key}`,\n        reason: \"accessor properties are not portable JSON data\",\n      };\n    }\n\n    if (!descriptor.enumerable && !allowedNonEnumerable.has(key)) {\n      return {\n        path: `${path}.${key}`,\n        reason: \"non-enumerable properties would be omitted from JSON\",\n      };\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "constructa-schema",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Portable schemas and types for Constructa generator definitions.",
   "private": false,
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jack-WebDev/constructa.git",
+    "directory": "packages/schema"
+  },
   "type": "module",
   "files": [
     "dist"
@@ -17,15 +22,15 @@
       "default": "./dist/index.js"
     }
   },
-  "scripts": {
-    "build": "tsdown",
-    "check-types": "tsc --noEmit"
-  },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@constructa/config": "workspace:*",
-    "typescript": "catalog:"
+    "typescript": "^6.0.3",
+    "@constructa/config": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check-types": "tsc --noEmit"
   }
-}
+}