@vibes.diy/api-types 14.0.14 → 14.0.15

package/app.js

@@ -5,7 +5,8 @@ import { dashAuthType, vibeUserEnv, vibeFile, FSMode, NeedOneAppSlugUserSlug } f
 import { PromptAndBlockMsgs } from "./chat.js";
 import { notificationRow, notificationTypeEnum } from "./notifications.js";
 import { anonWriteMode, dbPosture, postureIntent } from "./db-acls.js";
-export const ReqEnsureAppSlug = type({
+import { lazyType } from "./lazy-type.js";
+export const ReqEnsureAppSlug = lazyType(() => type({
     type: "'vibes.diy.req-ensure-app-slug'",
     auth: dashAuthType,
     mode: FSMode,
@@ -16,30 +17,30 @@ export const ReqEnsureAppSlug = type({
     "anonWrite?": anonWriteMode,
     "from?": type({ ownerHandle: "string", appSlug: "string" }),
     fileSystem: [vibeFile, "[]"],
-}).and(NeedOneAppSlugUserSlug);
-export const resEnsureAppSlugOk = type({
+}).and(NeedOneAppSlugUserSlug));
+export const resEnsureAppSlugOk = lazyType(() => type({
     type: "'vibes.diy.res-ensure-app-slug'",
     env: vibeUserEnv,
     fileSystem: [fileSystemItem, "[]"],
-}).and(FileSystemRefFields);
-export const resEnsureAppSlugRequireLogin = type({
+}).and(FileSystemRefFields));
+export const resEnsureAppSlugRequireLogin = lazyType(() => type({
     type: "'vibes.diy.res-error'",
     error: type({ message: "string", code: "'require-login'" }),
-});
+}));
 export function isResEnsureAppSlugOk(obj) {
     return !(resEnsureAppSlugOk(obj) instanceof type.errors);
 }
-export const resEnsureAppSlugUserSlugInvalid = type({
+export const resEnsureAppSlugUserSlugInvalid = lazyType(() => type({
     type: "'vibes.diy.res-error'",
     error: type({ message: "string", code: "'user-slug-invalid'" }),
-});
+}));
 export function isResEnsureAppSlugUserSlugInvalid(obj) {
     return !(resEnsureAppSlugUserSlugInvalid(obj) instanceof type.errors);
 }
-export const resEnsureAppSlugInvalid = type({
+export const resEnsureAppSlugInvalid = lazyType(() => type({
     type: "'vibes.diy.res-error'",
     error: type({ message: "string", code: "'app-slug-invalid'" }),
-});
+}));
 export const HANDLE_REQUIRED_CODE = "handle-required";
 export const HANDLE_REQUIRED_MESSAGE = "no handle bound to this account — choose a handle before creating or publishing (createHandleBinding)";
 export const FORK_DST_HANDLE_NOT_BOUND_CODE = "handle-not-bound";
@@ -51,24 +52,24 @@ export const CARRY_SRC_NOT_GRANT_CODE = "not-grant";
 export const CARRY_SRC_SETTINGS_NOT_FOUND_CODE = "app-settings-not-found";
 export const PUSH_FROM_NOT_OWNED_CODE = "from-not-owned";
 export const PUSH_FROM_CARRY_FAILED_CODE = "from-carry-failed";
-export const resPushFromNotOwned = type({
+export const resPushFromNotOwned = lazyType(() => type({
     type: "'vibes.diy.res-error'",
     error: type({ message: "string", code: "'from-not-owned'" }),
-});
-export const resPushFromCarryFailed = type({
+}));
+export const resPushFromCarryFailed = lazyType(() => type({
     type: "'vibes.diy.res-error'",
     error: type({ message: "string", code: "'from-carry-failed'" }),
-});
+}));
 export const CARRY_APP_SETTINGS_REFUSAL_CODES = [
     CARRY_DST_NOT_FOUND_CODE,
     CARRY_SRC_NOT_FOUND_CODE,
     CARRY_SRC_NOT_GRANT_CODE,
     CARRY_SRC_SETTINGS_NOT_FOUND_CODE,
 ];
-export const resHandleRequired = type({
+export const resHandleRequired = lazyType(() => type({
     type: "'vibes.diy.res-error'",
     error: type({ message: "string", code: "'handle-required'" }),
-});
+}));
 export function isResHandleRequired(obj) {
     return !(resHandleRequired(obj) instanceof type.errors);
 }
@@ -78,71 +79,71 @@ export function mkResHandleRequired() {
         error: { message: HANDLE_REQUIRED_MESSAGE, code: "handle-required" },
     };
 }
-const resEnsureAppSlugMaxAppsError = type({
+const resEnsureAppSlugMaxAppsError = lazyType(() => type({
     type: "'vibes.diy.res-error'",
     error: type({ message: "string", code: "'max-app-slugs-reached'" }),
-});
+}));
 export function isResEnsureAppSlugMaxAppsError(obj) {
     return !(resEnsureAppSlugMaxAppsError(obj) instanceof type.errors);
 }
 export function isResEnsureAppSlugInvalid(obj) {
     return !(resEnsureAppSlugInvalid(obj) instanceof type.errors);
 }
-export const resEnsureAppSlugError = resEnsureAppSlugRequireLogin
+export const resEnsureAppSlugError = lazyType(() => resEnsureAppSlugRequireLogin
     .or(resEnsureAppSlugUserSlugInvalid)
     .or(resEnsureAppSlugInvalid)
     .or(resEnsureAppSlugMaxAppsError)
     .or(resHandleRequired)
     .or(resPushFromNotOwned)
-    .or(resPushFromCarryFailed);
-export const resEnsureAppSlug = resEnsureAppSlugOk.or(resEnsureAppSlugError);
+    .or(resPushFromCarryFailed));
+export const resEnsureAppSlug = lazyType(() => resEnsureAppSlugOk.or(resEnsureAppSlugError));
 export function isResEnsureAppSlugError(obj) {
     return !(resEnsureAppSlugError(obj) instanceof type.errors);
 }
 export function isResEnsureAppSlug(obj) {
     return !(resEnsureAppSlug(obj) instanceof type.errors);
 }
-export const reqGetChatDetails = type({
+export const reqGetChatDetails = lazyType(() => type({
     type: "'vibes.diy.req-get-chat-details'",
     auth: dashAuthType,
     ownerHandle: "string",
     appSlug: "string",
     "chatId?": "string",
     "asHandle?": "string",
-});
-export const resChatDetailsPrompt = type({
+}));
+export const resChatDetailsPrompt = lazyType(() => type({
     prompt: "string",
     fsId: "string",
     created: "string",
-});
-export const resGetChatDetails = type({
+}));
+export const resGetChatDetails = lazyType(() => type({
     type: "'vibes.diy.res-get-chat-details'",
     "chatId?": "string",
     ownerHandle: "string",
     appSlug: "string",
     prompts: resChatDetailsPrompt.array(),
-});
+}));
 export function isResGetChatDetails(obj) {
     return !(resGetChatDetails(obj) instanceof type.errors);
 }
-export const reqGetApplicationChat = type({
+export const reqGetApplicationChat = lazyType(() => type({
     type: "'vibes.diy.req-get-application-chat'",
     auth: dashAuthType,
     chatId: "string",
     "appSlug?": "string",
     "ownerHandle?": "string",
-});
-export const resGetApplicationChat = type({
+}));
+export const resGetApplicationChat = lazyType(() => type({
     type: "'vibes.diy.res-get-application-chat'",
     "chatId?": "string",
     "appSlug?": "string",
     "ownerHandle?": "string",
     blocks: PromptAndBlockMsgs.array(),
-});
+}));
 export function isResGetApplicationChat(obj) {
     return !(resGetApplicationChat(obj) instanceof type.errors);
 }
-export const reqGetAppByFsId = type({
+export const reqGetAppByFsId = lazyType(() => type({
     type: "'vibes.diy.req-get-app-by-fsid'",
     "auth?": dashAuthType,
     "fsId?": "string",
@@ -151,11 +152,11 @@ export const reqGetAppByFsId = type({
     "token?": "string",
     "selectMode?": "'published'|'ownerLatest'|'ownerDraft'",
     "asHandle?": "string",
-});
+}));
 export function isReqGetAppByFsId(obj) {
     return !(reqGetAppByFsId(obj) instanceof type.errors);
 }
-export const resGetAppByFsId = type({
+export const resGetAppByFsId = lazyType(() => type({
     type: "'vibes.diy.res-get-app-by-fsid'",
     "error?": "string",
     appSlug: "string",
@@ -176,75 +177,75 @@ export const resGetAppByFsId = type({
     fileSystem: [fileSystemItem, "[]"],
     meta: MetaItem.array(),
     created: "string",
-});
+}));
 export function isResGetAppByFsId(obj) {
     return !(resGetAppByFsId(obj) instanceof type.errors);
 }
-export const reqListVersions = type({
+export const reqListVersions = lazyType(() => type({
     type: "'vibes.diy.req-list-versions'",
     "auth?": dashAuthType,
     appSlug: "string",
     ownerHandle: "string",
-});
+}));
 export function isReqListVersions(obj) {
     return !(reqListVersions(obj) instanceof type.errors);
 }
-export const resListVersionsItem = type({
+export const resListVersionsItem = lazyType(() => type({
     fsId: "string",
     mode: "'production'|'dev'",
     releaseSeq: "number",
     created: "string",
     published: "boolean",
-});
-export const resListVersions = type({
+}));
+export const resListVersions = lazyType(() => type({
     type: "'vibes.diy.res-list-versions'",
     appSlug: "string",
     ownerHandle: "string",
     items: resListVersionsItem.array(),
     "lockedFsId?": "string",
-});
+}));
 export function isResListVersions(obj) {
     return !(resListVersions(obj) instanceof type.errors);
 }
-export const reqGetByUserSlugAppSlug = type({
+export const reqGetByUserSlugAppSlug = lazyType(() => type({
     type: "'vibes.diy.req-get-by-user-slug-app-slug'",
     auth: dashAuthType,
     ownerHandle: "string",
     appSlug: "string",
-});
-export const reqListUserSlugAppSlug = type({
+}));
+export const reqListUserSlugAppSlug = lazyType(() => type({
     type: "'vibes.diy.req-list-user-slug-app-slug'",
     auth: dashAuthType,
     "ownerHandle?": "string",
     "appSlug?": "string",
-});
+}));
 export function isReqListUserSlugAppSlug(obj) {
     return !(reqListUserSlugAppSlug(obj) instanceof type.errors);
 }
-export const resListUserSlugAppSlugItem = type({
+export const resListUserSlugAppSlugItem = lazyType(() => type({
     userId: "string",
     ownerHandle: "string",
     appSlugs: type("string").array(),
-});
-export const resListUserSlugAppSlug = type({
+}));
+export const resListUserSlugAppSlug = lazyType(() => type({
     type: "'vibes.diy.res-list-user-slug-app-slug'",
     items: resListUserSlugAppSlugItem.array(),
-});
+}));
 export function isResListUserSlugAppSlug(obj) {
     return !(resListUserSlugAppSlug(obj) instanceof type.errors);
 }
-export const reqListRecentVibes = type({
+export const reqListRecentVibes = lazyType(() => type({
     type: "'vibes.diy.req-list-recent-vibes'",
     auth: dashAuthType,
     "limit?": "number",
     "cursor?": "string",
     "includeUnpublished?": "boolean",
     "asHandle?": "string",
-});
+}));
 export function isReqListRecentVibes(obj) {
     return !(reqListRecentVibes(obj) instanceof type.errors);
 }
-export const resRecentVibesItem = type({
+export const resRecentVibesItem = lazyType(() => type({
     ownerHandle: "string",
     appSlug: "string",
     updated: "string",
@@ -253,87 +254,87 @@ export const resRecentVibesItem = type({
     "pinnedAt?": "string",
     "neverPublished?": "boolean",
     "unpublishedAt?": "string",
-});
-export const resListRecentVibes = type({
+}));
+export const resListRecentVibes = lazyType(() => type({
     type: "'vibes.diy.res-list-recent-vibes'",
     items: resRecentVibesItem.array(),
     "nextCursor?": "string",
     "viewedAs?": "string",
-});
+}));
 export function isResListRecentVibes(obj) {
     return !(resListRecentVibes(obj) instanceof type.errors);
 }
-export const reqPinRecentVibe = type({
+export const reqPinRecentVibe = lazyType(() => type({
     type: "'vibes.diy.req-pin-recent-vibe'",
     auth: dashAuthType,
     ownerHandle: "string",
     appSlug: "string",
     pin: "boolean",
-});
+}));
 export function isReqPinRecentVibe(obj) {
     return !(reqPinRecentVibe(obj) instanceof type.errors);
 }
-export const resPinRecentVibe = type({
+export const resPinRecentVibe = lazyType(() => type({
     type: "'vibes.diy.res-pin-recent-vibe'",
     ownerHandle: "string",
     appSlug: "string",
     pinnedAt: "string",
-});
+}));
 export function isResPinRecentVibe(obj) {
     return !(resPinRecentVibe(obj) instanceof type.errors);
 }
-export const reqSetUnpublish = type({
+export const reqSetUnpublish = lazyType(() => type({
     type: "'vibes.diy.req-set-unpublish'",
     auth: dashAuthType,
     ownerHandle: "string",
     appSlug: "string",
     unpublish: "boolean",
-});
+}));
 export function isReqSetUnpublish(obj) {
     return !(reqSetUnpublish(obj) instanceof type.errors);
 }
-export const resSetUnpublish = type({
+export const resSetUnpublish = lazyType(() => type({
     type: "'vibes.diy.res-set-unpublish'",
     ownerHandle: "string",
     appSlug: "string",
     unpublishedAt: "string",
     previousUnpublishedAt: "string",
-});
+}));
 export function isResSetUnpublish(obj) {
     return !(resSetUnpublish(obj) instanceof type.errors);
 }
-export const reqSetVibeChips = type({
+export const reqSetVibeChips = lazyType(() => type({
     type: "'vibes.diy.req-set-vibe-chips'",
     auth: dashAuthType,
     ownerHandle: "string",
     appSlug: "string",
     chips: "string[]",
     "fsId?": "string",
-});
+}));
 export function isReqSetVibeChips(obj) {
     return !(reqSetVibeChips(obj) instanceof type.errors);
 }
-export const resSetVibeChips = type({
+export const resSetVibeChips = lazyType(() => type({
     type: "'vibes.diy.res-set-vibe-chips'",
     ownerHandle: "string",
     appSlug: "string",
     fsId: "string",
     releaseSeq: "number",
     chips: "string[]",
-});
+}));
 export function isResSetVibeChips(obj) {
     return !(resSetVibeChips(obj) instanceof type.errors);
 }
-export const reqAppTickStatus = type({
+export const reqAppTickStatus = lazyType(() => type({
     type: "'vibes.diy.req-app-tick-status'",
     auth: dashAuthType,
     ownerHandle: "string",
     appSlug: "string",
-});
+}));
 export function isReqAppTickStatus(obj) {
     return !(reqAppTickStatus(obj) instanceof type.errors);
 }
-export const resAppTickStatus = type({
+export const resAppTickStatus = lazyType(() => type({
     type: "'vibes.diy.res-app-tick-status'",
     ownerHandle: "string",
     appSlug: "string",
@@ -349,56 +350,56 @@ export const resAppTickStatus = type({
     graceMs: "number",
     overdueMs: "number",
     healed: "boolean",
-});
+}));
 export function isResAppTickStatus(obj) {
     return !(resAppTickStatus(obj) instanceof type.errors);
 }
-export const reqAppTickRearm = type({
+export const reqAppTickRearm = lazyType(() => type({
     type: "'vibes.diy.req-app-tick-rearm'",
     auth: dashAuthType,
     ownerHandle: "string",
     appSlug: "string",
-});
+}));
 export function isReqAppTickRearm(obj) {
     return !(reqAppTickRearm(obj) instanceof type.errors);
 }
-export const resAppTickRearm = type({
+export const resAppTickRearm = lazyType(() => type({
     type: "'vibes.diy.res-app-tick-rearm'",
     ownerHandle: "string",
     appSlug: "string",
     state: "'unscheduled'|'running'|'healthy'|'overdue'|'dead'",
     intervalMs: "number|null",
     nextAlarmAt: "string|null",
-});
+}));
 export function isResAppTickRearm(obj) {
     return !(resAppTickRearm(obj) instanceof type.errors);
 }
-export const reqSetVersionLock = type({
+export const reqSetVersionLock = lazyType(() => type({
     type: "'vibes.diy.req-set-version-lock'",
     auth: dashAuthType,
     appSlug: "string",
     ownerHandle: "string",
     "fsId?": "string",
-});
+}));
 export function isReqSetVersionLock(obj) {
     return !(reqSetVersionLock(obj) instanceof type.errors);
 }
-export const resSetVersionLock = type({
+export const resSetVersionLock = lazyType(() => type({
     type: "'vibes.diy.res-set-version-lock'",
     appSlug: "string",
     ownerHandle: "string",
     lockedFsId: "string",
     previousLockedFsId: "string",
-});
+}));
 export function isResSetVersionLock(obj) {
     return !(resSetVersionLock(obj) instanceof type.errors);
 }
 export function isReqGetByUserSlugAppSlug(obj) {
     return !(reqGetByUserSlugAppSlug(obj) instanceof type.errors);
 }
-export const resGetByUserSlugAppSlug = type({
+export const resGetByUserSlugAppSlug = lazyType(() => type({
     type: "'vibes.diy.res-get-by-user-slug-app-slug'",
-}).and(FileSystemRefFields);
+}).and(FileSystemRefFields));
 export function isResGetByUserSlugAppSlug(obj) {
     const res = resGetByUserSlugAppSlug(obj);
     if (res instanceof type.errors) {
@@ -406,7 +407,7 @@ export function isResGetByUserSlugAppSlug(obj) {
     }
     return !(resGetByUserSlugAppSlug(obj) instanceof type.errors);
 }
-export const reqForkApp = type({
+export const reqForkApp = lazyType(() => type({
     type: "'vibes.diy.req-fork-app'",
     auth: dashAuthType,
     srcUserSlug: "string",
@@ -416,11 +417,11 @@ export const reqForkApp = type({
     "dstAppSlug?": "string",
     "dstOwnerHandle?": "string",
     "cacheKey?": "string",
-});
+}));
 export function isReqForkApp(obj) {
     return !(reqForkApp(obj) instanceof type.errors);
 }
-export const resForkApp = type({
+export const resForkApp = lazyType(() => type({
     type: "'vibes.diy.res-fork-app'",
     ownerHandle: "string",
     appSlug: "string",
@@ -429,52 +430,52 @@ export const resForkApp = type({
     srcUserSlug: "string",
     srcAppSlug: "string",
     "seededFromCache?": "boolean",
-});
+}));
 export function isResForkApp(obj) {
     return !(resForkApp(obj) instanceof type.errors);
 }
-export const reqCarryAppSettings = type({
+export const reqCarryAppSettings = lazyType(() => type({
     type: "'vibes.diy.req-carry-app-settings'",
     auth: dashAuthType,
     srcUserSlug: "string",
     srcAppSlug: "string",
     dstOwnerHandle: "string",
     dstAppSlug: "string",
-});
+}));
 export function isReqCarryAppSettings(obj) {
     return !(reqCarryAppSettings(obj) instanceof type.errors);
 }
-export const resCarryAppSettings = type({
+export const resCarryAppSettings = lazyType(() => type({
     type: "'vibes.diy.res-carry-app-settings'",
     carried: "string[]",
     skippedPresent: "string[]",
-});
+}));
 export function isResCarryAppSettings(obj) {
     return !(resCarryAppSettings(obj) instanceof type.errors);
 }
-export const ResSetModeFs = type({
+export const ResSetModeFs = lazyType(() => type({
     type: "'vibes.diy.res-set-mode-fs'",
     fsId: "string",
     appSlug: "string",
     ownerHandle: "string",
     mode: FSMode,
-});
+}));
 export function isResSetModeFs(obj) {
     return !(ResSetModeFs(obj) instanceof type.errors);
 }
-export const ReqSetModeFs = type({
+export const ReqSetModeFs = lazyType(() => type({
     type: "'vibes.diy.req-set-mode-fs'",
     auth: dashAuthType,
     fsId: "string",
     appSlug: "string",
     ownerHandle: "string",
     mode: FSMode,
-});
+}));
 export const reqSetModeFs = ReqSetModeFs;
 export function isReqSetModeFs(obj) {
     return !(ReqSetModeFs(obj) instanceof type.errors);
 }
-export const reqPublishApp = type({
+export const reqPublishApp = lazyType(() => type({
     type: "'vibes.diy.req-publish-app'",
     auth: dashAuthType,
     appSlug: "string",
@@ -484,11 +485,11 @@ export const reqPublishApp = type({
     "posture?": postureIntent,
     "seedPosture?": dbPosture,
     "anonWrite?": anonWriteMode,
-});
+}));
 export function isReqPublishApp(obj) {
     return !(reqPublishApp(obj) instanceof type.errors);
 }
-export const resPublishApp = type({
+export const resPublishApp = lazyType(() => type({
     type: "'vibes.diy.res-publish-app'",
     appSlug: "string",
     ownerHandle: "string",
@@ -498,142 +499,142 @@ export const resPublishApp = type({
     published: "boolean",
     "envelopeError?": "string",
     "suppressed?": "boolean",
-});
+}));
 export function isResPublishApp(obj) {
     return !(resPublishApp(obj) instanceof type.errors);
 }
-export const reqSeedRemove = type({
+export const reqSeedRemove = lazyType(() => type({
     type: "'vibes.diy.req-seed-remove'",
     auth: dashAuthType,
     appSlug: "string",
     ownerHandle: "string",
-});
+}));
 export function isReqSeedRemove(obj) {
     return !(reqSeedRemove(obj) instanceof type.errors);
 }
-export const resSeedRemove = type({
+export const resSeedRemove = lazyType(() => type({
     type: "'vibes.diy.res-seed-remove'",
     appSlug: "string",
     ownerHandle: "string",
     removed: "number",
     failed: "number",
-});
+}));
 export function isResSeedRemove(obj) {
     return !(resSeedRemove(obj) instanceof type.errors);
 }
-export const reqSeedRerun = type({
+export const reqSeedRerun = lazyType(() => type({
     type: "'vibes.diy.req-seed-rerun'",
     auth: dashAuthType,
     appSlug: "string",
     ownerHandle: "string",
-});
+}));
 export function isReqSeedRerun(obj) {
     return !(reqSeedRerun(obj) instanceof type.errors);
 }
-export const resSeedRerun = type({
+export const resSeedRerun = lazyType(() => type({
     type: "'vibes.diy.res-seed-rerun'",
     appSlug: "string",
     ownerHandle: "string",
     applied: "number",
     failed: "number",
-});
+}));
 export function isResSeedRerun(obj) {
     return !(resSeedRerun(obj) instanceof type.errors);
 }
-export const ReqListHandleBindings = type({
+export const ReqListHandleBindings = lazyType(() => type({
     type: "'vibes.diy.req-list-user-slug-bindings'",
     auth: dashAuthType,
     "asHandle?": "string",
-});
+}));
 export function isReqListHandleBindings(obj) {
     return !(ReqListHandleBindings(obj) instanceof type.errors);
 }
-export const HandleBindingItem = type({
+export const HandleBindingItem = lazyType(() => type({
     ownerHandle: "string",
     tenant: "string",
     created: "string",
     appSlugCount: "number",
-});
-export const ResListHandleBindings = type({
+}));
+export const ResListHandleBindings = lazyType(() => type({
     type: "'vibes.diy.res-list-user-slug-bindings'",
     items: HandleBindingItem.array(),
     "viewedAs?": "string",
-});
+}));
 export function isResListHandleBindings(obj) {
     return !(ResListHandleBindings(obj) instanceof type.errors);
 }
-export const ReqCreateHandleBinding = type({
+export const ReqCreateHandleBinding = lazyType(() => type({
     type: "'vibes.diy.req-create-user-slug-binding'",
     auth: dashAuthType,
     "ownerHandle?": "string",
-});
+}));
 export function isReqCreateHandleBinding(obj) {
     return !(ReqCreateHandleBinding(obj) instanceof type.errors);
 }
-export const ResCreateHandleBinding = type({
+export const ResCreateHandleBinding = lazyType(() => type({
     type: "'vibes.diy.res-create-user-slug-binding'",
     ownerHandle: "string",
     tenant: "string",
     created: "string",
-});
+}));
 export function isResCreateHandleBinding(obj) {
     return !(ResCreateHandleBinding(obj) instanceof type.errors);
 }
-export const ReqDeleteHandleBinding = type({
+export const ReqDeleteHandleBinding = lazyType(() => type({
     type: "'vibes.diy.req-delete-user-slug-binding'",
     auth: dashAuthType,
     ownerHandle: "string",
-});
+}));
 export function isReqDeleteHandleBinding(obj) {
     return !(ReqDeleteHandleBinding(obj) instanceof type.errors);
 }
-export const ResDeleteHandleBinding = type({
+export const ResDeleteHandleBinding = lazyType(() => type({
     type: "'vibes.diy.res-delete-user-slug-binding'",
     ownerHandle: "string",
     deleted: "boolean",
-});
+}));
 export function isResDeleteHandleBinding(obj) {
     return !(ResDeleteHandleBinding(obj) instanceof type.errors);
 }
-export const ReqSuggestHandleCandidates = type({
+export const ReqSuggestHandleCandidates = lazyType(() => type({
     type: "'vibes.diy.req-suggest-handle-candidates'",
     auth: dashAuthType,
     "count?": "number",
-});
+}));
 export function isReqSuggestHandleCandidates(obj) {
     return !(ReqSuggestHandleCandidates(obj) instanceof type.errors);
 }
-export const ResSuggestHandleCandidates = type({
+export const ResSuggestHandleCandidates = lazyType(() => type({
     type: "'vibes.diy.res-suggest-handle-candidates'",
     wordSlugs: type("string").array(),
     clerkSuggestions: type("string").array(),
     "ranked?": type("string").array(),
-});
+}));
 export function isResSuggestHandleCandidates(obj) {
     return !(ResSuggestHandleCandidates(obj) instanceof type.errors);
 }
-export const ReqConfirmPlaceholderHandle = type({
+export const ReqConfirmPlaceholderHandle = lazyType(() => type({
     type: "'vibes.diy.req-confirm-placeholder-handle'",
     auth: dashAuthType,
     appSlug: "string",
     ownerHandle: "string",
     routeHandle: "string",
-});
+}));
 export function isReqConfirmPlaceholderHandle(obj) {
     return !(ReqConfirmPlaceholderHandle(obj) instanceof type.errors);
 }
-export const ResConfirmPlaceholderHandle = type({
+export const ResConfirmPlaceholderHandle = lazyType(() => type({
     type: "'vibes.diy.res-confirm-placeholder-handle'",
     ownerHandle: "string",
     appSlug: "string",
     chosenHandle: "string",
     defaultHandle: "string",
     moved: "boolean",
-});
+}));
 export function isResConfirmPlaceholderHandle(obj) {
     return !(ResConfirmPlaceholderHandle(obj) instanceof type.errors);
 }
-export const reqListNotifications = type({
+export const reqListNotifications = lazyType(() => type({
     type: "'vibes.diy.req-list-notifications'",
     auth: dashAuthType,
     "appSlug?": "string",
@@ -641,35 +642,35 @@ export const reqListNotifications = type({
     "notificationType?": notificationTypeEnum,
     "cursor?": "string",
     "limit?": "number",
-});
+}));
 export function isReqListNotifications(obj) {
     return !(reqListNotifications(obj) instanceof type.errors);
 }
-export const resListNotifications = type({
+export const resListNotifications = lazyType(() => type({
     type: "'vibes.diy.res-list-notifications'",
     items: notificationRow.array(),
     "nextCursor?": "string",
     unreadCount: "number",
-});
+}));
 export function isResListNotifications(obj) {
     return !(resListNotifications(obj) instanceof type.errors);
 }
-export const reqMarkNotificationsRead = type({
+export const reqMarkNotificationsRead = lazyType(() => type({
     type: "'vibes.diy.req-mark-notifications-read'",
     auth: dashAuthType,
     "ids?": "string[]",
-});
+}));
 export function isReqMarkNotificationsRead(obj) {
     return !(reqMarkNotificationsRead(obj) instanceof type.errors);
 }
-export const resMarkNotificationsRead = type({
+export const resMarkNotificationsRead = lazyType(() => type({
     type: "'vibes.diy.res-mark-notifications-read'",
     ok: "number",
-});
+}));
 export function isResMarkNotificationsRead(obj) {
     return !(resMarkNotificationsRead(obj) instanceof type.errors);
 }
-export const vibeLogEventWire = type({
+export const vibeLogEventWire = lazyType(() => type({
     id: "string",
     ts: "string",
     lane: "'backend'|'client'",
@@ -679,10 +680,10 @@ export const vibeLogEventWire = type({
     body: "string",
     sessionId: "string|null",
     viewerHandle: "string|null",
-});
+}));
 export const APP_LOGS_LIMIT_DEFAULT = 100;
 export const APP_LOGS_LIMIT_MAX = 500;
-export const reqAppLogs = type({
+export const reqAppLogs = lazyType(() => type({
     type: "'vibes.diy.req-app-logs'",
     auth: dashAuthType,
     ownerHandle: "string",
@@ -692,18 +693,18 @@ export const reqAppLogs = type({
     "level?": "'debug'|'info'|'warn'|'error'",
     "probeLatest?": "boolean",
     limit: "number",
-});
+}));
 export function isReqAppLogs(obj) {
     return !(reqAppLogs(obj) instanceof type.errors);
 }
-export const resAppLogs = type({
+export const resAppLogs = lazyType(() => type({
     type: "'vibes.diy.res-app-logs'",
     ownerHandle: "string",
     appSlug: "string",
     events: vibeLogEventWire.array(),
     nextCursor: "string|null",
     "latestTs?": "string|null",
-});
+}));
 export function isResAppLogs(obj) {
     return !(resAppLogs(obj) instanceof type.errors);
 }