lucy-cli 2.0.0-beta.4 → 2.0.0-beta.6

package/files/templates/expo verse[D]/files/eslint.config.mjs

@@ -0,0 +1,185 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// https://docs.expo.dev/guides/using-eslint/
+import eslint from '@eslint/js';
+// @ts-ignore
+import jsdoc from 'eslint-plugin-jsdoc';
+import namedImportSpacing from 'eslint-plugin-named-import-spacing';
+import simpleImportSort from 'eslint-plugin-simple-import-sort';
+import globals from 'globals';
+import { createRequire } from 'module';
+import tseslint from 'typescript-eslint';
+
+const require = createRequire(import.meta.url);
+const expoConfig = require('eslint-config-expo/flat.js');
+
+export default tseslint.config(
+	eslint.configs.recommended,
+	// eslint-disable-next-line import/no-named-as-default-member
+	tseslint.configs.recommendedTypeChecked,
+	jsdoc.configs['flat/recommended-typescript'],
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+	expoConfig,
+	{
+		ignores: ['dist/*'],
+	},
+	{
+		plugins: {
+			'simple-import-sort': simpleImportSort,
+			'named-import-spacing': namedImportSpacing,
+		},
+		settings: {
+			'import/resolver': {
+				typescript: {
+					project: './tsconfig.json',
+				}
+			}
+		},
+		languageOptions: {
+			// eslint-disable-next-line import/no-named-as-default-member
+			parser: tseslint.parser,
+			parserOptions: {
+				projectService: true,
+			},
+			ecmaVersion: 2020,
+			sourceType: 'module',
+			globals: {
+				$w: 'readonly',
+				...globals.browser,
+				...globals.node,
+				// ...globals.es6,
+			},
+		},
+		rules: {
+			'jsdoc/require-description': 'warn',
+			'no-console': ['error'],
+			'no-restricted-imports': [
+				'error',
+				{
+					'patterns': ['*/**/backend/*', '*/**/public/*']
+				}
+			],
+			'no-restricted-syntax': [
+				'warn',
+				{
+					selector: 'StaticBlock',
+					message: 'Static blocks are not allowed in classes.',
+				},
+				{
+					selector: "MemberExpression[object.name='globalThis'][property.name='console']",
+					message: 'Using globalThis.console is not allowed.'
+				},
+				{
+					selector: "CallExpression[callee.property.name='runPromise'][callee.object.name='runtime']",
+					message: 'Usage of runtime.runPromise() is discouraged.',
+				},
+				{
+					selector: "CallExpression[callee.property.name='runFork'][callee.object.name='runtime']",
+					message: 'Usage of runtime.runFork() is discouraged.',
+				}
+			],
+			'@typescript-eslint/no-unsafe-argument': 'error',
+			'@typescript-eslint/no-unsafe-assignment': 'off',
+			'@typescript-eslint/no-unsafe-call': 'error',
+			'@typescript-eslint/no-unsafe-member-access': 'off',
+			'@typescript-eslint/no-unsafe-return': 'error',
+			quotes: [2, 'single', { avoidEscape: true, allowTemplateLiterals: true }],
+			curly: ['error', 'multi-line'],
+			'simple-import-sort/imports': 'error',
+			'simple-import-sort/exports': 'error',
+			indent: ['error', 'tab'],
+			'no-tabs': 0,
+			'semi-style': ['error', 'last'],
+			semi: [2, 'always'],
+			'object-curly-spacing': ['error', 'always'],
+			'space-in-parens': ['error', 'never'],
+			'newline-before-return': 'error',
+			'space-before-blocks': ['error', { functions: 'always', keywords: 'always', classes: 'always' }],
+			'comma-spacing': ['error', { before: false, after: true }],
+			'no-multi-spaces': 'error',
+			'import/newline-after-import': ['error', { count: 1 }],
+			'named-import-spacing/named-import-spacing': 2,
+			'@typescript-eslint/no-unused-vars': 'warn',
+			'import/no-unresolved': [0],
+			'no-forbidden-relative-imports': [0],
+			'@typescript-eslint/triple-slash-reference': 'off',
+			'@typescript-eslint/member-ordering': [
+				'error',
+				{
+					classes: [
+						'constructor',
+						'private-instance-field',
+						'protected-instance-field',
+						'public-instance-field',
+						'public-instance-method',
+						'private-instance-method',
+					],
+				},
+			],
+			'@typescript-eslint/naming-convention': [
+				'error',
+				{
+					selector: ['variable'],
+					format: ['camelCase', 'UPPER_CASE'],
+					leadingUnderscore: 'allow',
+				},
+				{
+					selector: ['function'],
+					format: ['camelCase', 'PascalCase'],
+					leadingUnderscore: 'allow',
+				},
+				{
+					selector: ['objectLiteralMethod',],
+					format: ['camelCase', 'PascalCase'],
+					leadingUnderscore: 'allow',
+				},
+				{
+					selector: ['import',],
+					format: ['camelCase', 'PascalCase'],
+					leadingUnderscore: 'allow',
+				},
+				{
+					selector: ['objectLiteralProperty'],
+					format: null,
+					leadingUnderscore: 'allow',
+				},
+				{
+					selector: 'memberLike',
+					modifiers: ['private'],
+					format: ['camelCase'],
+					leadingUnderscore: 'require',
+				},
+				{
+					selector: 'memberLike',
+					modifiers: ['protected'],
+					format: ['camelCase'],
+					leadingUnderscore: 'require',
+				},
+				{
+					selector: 'memberLike',
+					modifiers: ['public'],
+					format: ['camelCase'],
+					leadingUnderscore: 'forbid',
+				},
+				{
+					selector: ['parameterProperty', 'parameter'],
+					format: ['camelCase'],
+					leadingUnderscore: 'forbid',
+				},
+				{
+					selector: 'default',
+					format: ['UPPER_CASE'],
+					leadingUnderscore: 'forbid',
+					trailingUnderscore: 'forbid',
+					custom: {
+						regex: '^[A-Z_]+$',
+						match: true,
+					},
+				},
+				{
+					selector: 'typeLike',
+					format: ['PascalCase'],
+				},
+			],
+		},
+	},
+);

package/files/templates/expo verse[D]/files/global.css

@@ -0,0 +1,47 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+@layer base {
+    :root {
+      --background: 0 0% 100%;
+      --foreground: 240 10% 3.9%;
+      --card: 0 0% 100%;
+      --card-foreground: 240 10% 3.9%;
+      --popover: 0 0% 100%;
+      --popover-foreground: 240 10% 3.9%;
+      --primary: 240 5.9% 10%;
+      --primary-foreground: 0 0% 98%;
+      --secondary: 240 4.8% 95.9%;
+      --secondary-foreground: 240 5.9% 10%;
+      --muted: 240 4.8% 95.9%;
+      --muted-foreground: 240 3.8% 46.1%;
+      --accent: 240 4.8% 95.9%;
+      --accent-foreground: 240 5.9% 10%;
+      --destructive: 0 84.2% 60.2%;
+      --destructive-foreground: 0 0% 98%;
+      --border: 240 5.9% 90%;
+      --input: 240 5.9% 90%;
+      --ring: 240 5.9% 10%;
+    }
+    .dark:root {
+      --background: 240 10% 3.9%;
+      --foreground: 0 0% 98%;
+      --card: 240 10% 3.9%;
+      --card-foreground: 0 0% 98%;
+      --popover: 240 10% 3.9%;
+      --popover-foreground: 0 0% 98%;
+      --primary: 0 0% 98%;
+      --primary-foreground: 240 5.9% 10%;
+      --secondary: 240 3.7% 15.9%;
+      --secondary-foreground: 0 0% 98%;
+      --muted: 240 3.7% 15.9%;
+      --muted-foreground: 240 5% 64.9%;
+      --accent: 240 3.7% 15.9%;
+      --accent-foreground: 0 0% 98%;
+      --destructive: 0 72% 51%;
+      --destructive-foreground: 0 0% 98%;
+      --border: 240 3.7% 15.9%;
+      --input: 240 3.7% 15.9%;
+      --ring: 240 4.9% 83.9%;
+    }
+}

package/files/templates/expo verse[D]/files/hooks/useColorScheme.ts

@@ -0,0 +1,17 @@
+import { useColorScheme as useNativewindColorScheme } from 'nativewind';
+
+/**
+ * Custom hook to get the current color scheme and provide methods to change it.
+ * This hook uses the nativewind's useColorScheme to access the color scheme.
+ * @returns An object containing the current color scheme, a method to set the color scheme,
+ */
+export function useColorScheme() {
+	const { colorScheme, setColorScheme, toggleColorScheme } = useNativewindColorScheme();
+	
+	return {
+		colorScheme: colorScheme ?? 'dark',
+		isDarkColorScheme: colorScheme === 'dark',
+		setColorScheme,
+		toggleColorScheme,
+	};
+}

package/files/templates/expo verse[D]/files/index.ts

@@ -0,0 +1,28 @@
+import '@/global.css';
+import '@/lib/utils/polyfills';
+
+import { registerRootComponent } from 'expo';
+import * as BackgroundTask from 'expo-background-task';
+import * as TaskManager from 'expo-task-manager';
+
+import { appLoaded, initializeBackgroundTask } from '@/lib/taskManager';
+
+import App from './App';
+import { BACKGROUND_TASK_IDENTIFIER } from './lib';
+
+// TaskManager.unregisterTaskAsync(BACKGROUND_TASK_IDENTIFIER);
+if (__DEV__) {
+	void TaskManager.getRegisteredTasksAsync().then((tasks) => {
+		// eslint-disable-next-line no-console
+		console.log('Registered Tasks: \n', tasks);
+	}).catch((error) => {
+		// eslint-disable-next-line no-console
+		console.error(error);
+	});
+}
+
+void initializeBackgroundTask(appLoaded);
+// registerRootComponent calls AppRegistry.registerComponent('main', () => App);
+// It also ensures that whether you load the app in Expo Go or in a native build,
+// the environment is set up appropriately
+registerRootComponent(App);

package/files/templates/expo verse[D]/files/lib/content.ts

@@ -0,0 +1,31 @@
+import { Data, Effect } from 'effect';
+
+import { FALLBACK_QUOTE } from '../constants/config';
+import { getQuote, loadData } from './data';
+import { getTimeData, renewState } from './helper';
+import { setState } from './state';
+
+export class ContentNotFoundError extends Data.TaggedError('ContentNotFoundError')<{reason: string}> {}
+
+export const getContent = () => {
+	return Effect.gen(function* () {
+		const { quoteTimestamp } = yield* getTimeData;
+		const { state } = yield* loadData;
+
+		if(state === null) return yield* Effect.succeed(FALLBACK_QUOTE);
+
+		if(yield* renewState(state)) {
+			const { quote, randomIndex } = yield* getQuote();
+			yield* setState({ ...state, index: randomIndex, date: quoteTimestamp }).pipe(Effect.catchAll((error) => Effect.logError('Failed to set state', error)));
+			
+			return quote;
+		}
+		const { quote } = yield* getQuote(state.index);
+		
+		return quote;
+	}).pipe(Effect.catchTags({
+		GetDataError: () => Effect.succeed(FALLBACK_QUOTE),
+		ParseError: () => Effect.succeed(FALLBACK_QUOTE),
+	}));
+};
+

package/files/templates/expo verse[D]/files/lib/data.ts

@@ -0,0 +1,180 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Data, Effect, Schema } from 'effect';
+import { getLocales } from 'expo-localization';
+import Papa from 'papaparse';
+
+import { Quote, quoteSchema } from '@/models';
+
+import { BASE_URL, CACHE_CONTROL, STORAGE_KEY, USER_AGENT } from '../constants/config';
+import { checkUpdata, getLanguage, getTimeData, hasLanguageChanged, renewState } from './helper';
+import { getState, getVersionInfo, setState } from './state';
+
+export class GetRemoteDataError extends Data.TaggedError('GetRemoteDataError')<{reason: string, error: unknown}> {}
+export class GetQuoteError extends Data.TaggedError('GetDataError')<{reason: string, error: unknown}> {}
+export class SaveQuoteError extends Data.TaggedError('SaveQuoteError')<{reason: string, error: unknown}> {}
+
+export const getRemoteData = (lang: string) => Effect.gen(function* () {
+	const response = yield* Effect.tryPromise({
+		try: () => fetch(`${BASE_URL.toString()}/${lang}.csv`, {
+			headers: {
+				'Cache-Control': CACHE_CONTROL,
+				'user-agent': USER_AGENT,
+			},
+		}),
+		catch: (error) => {			
+			return new GetRemoteDataError({
+				reason: 'Failed to fetch CSV data from remote',
+				error,
+			});
+		},
+	});
+
+	if (!response.ok) {
+		return yield* Effect.fail(new GetRemoteDataError({
+			reason: `Failed to fetch CSV: ${response.status} ${response.statusText}`,
+			error: new Error(`Failed to fetch CSV: ${response.status} ${response.statusText}`),
+		}));
+	}
+
+	const csvText = yield* Effect.tryPromise({
+		try: () => response.text(),
+		catch: (error) => {			
+			return new GetRemoteDataError({
+				reason: 'Failed to read CSV text from response',
+				error,
+			});
+		},
+	});
+	// Parse the CSV text
+	const { data: quotes, errors } = Papa.parse<Quote>(csvText, {
+		header: true,
+		skipEmptyLines: true
+	});
+
+	if (errors.length > 0) {
+		return yield* Effect.fail(new GetRemoteDataError({
+			reason: `CSV parsing errors: ${errors.map(e => e.message).join(', ')}`,
+			error: new Error(`CSV parsing errors: ${errors.map(e => e.message).join(', ')}`),
+		}));
+	}
+
+	if (quotes.length === 0) {
+		return yield* Effect.fail(new GetRemoteDataError({
+			reason: 'No quotes found in CSV data',
+			error: new Error('No quotes found in CSV data'),
+		}));
+	}
+
+	// Return the parsed quotes
+	return quotes;
+});
+
+export const getQuote = (index?: number) => Effect.gen(function* () {
+	const quotesRaw = yield* Effect.tryPromise({
+		try: () => AsyncStorage.getItem(STORAGE_KEY),
+		catch: (error) => {			
+			return new GetQuoteError({ reason: 'Failed to read quote to storage', error });
+		}
+	});
+	if(quotesRaw === null) {return (
+		yield *
+		Effect.fail(new GetQuoteError({ reason: 'No quotes found in storage', error: new Error('No quotes found in storage') }))
+	);} 
+
+	const quotesJSON = yield* Schema.decodeUnknown(Schema.parseJson())(quotesRaw).pipe(Effect.catchAll((error) => {
+		// eslint-disable-next-line no-console
+		console.error('Error decoding quote from storage:', error);
+		
+		return Effect.succeed(null);
+	}));
+	const data = yield* Schema.decodeUnknown(Schema.Array(quoteSchema))(quotesJSON);
+	const randomIndex = index ?? Math.floor(Math.random() * data.length);
+	
+	return { quote: data[randomIndex], randomIndex };
+});
+
+export const saveQuotes = (quote: Quote[]) => Effect.gen(function* () {
+	yield* Effect.tryPromise({
+		try: () => AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(quote)),
+		catch: (error) => {			
+			return new SaveQuoteError({ reason: 'Failed to save quote to storage', error });
+		}
+	});
+});
+
+export const getQuotes = () => Effect.gen(function* () {
+	const quotesRaw = yield* Effect.tryPromise({
+		try: () => AsyncStorage.getItem(STORAGE_KEY),
+		catch: (error) => {			
+			return new GetQuoteError({ reason: 'Failed to read quote to storage', error });
+		}
+	});
+	if(quotesRaw === null) {return (
+		yield *
+		Effect.fail(new GetQuoteError({ reason: 'No quotes found in storage', error: new Error('No quotes found in storage') }))
+	);} 
+
+	const quotesJSON = yield* Schema.decodeUnknown(Schema.parseJson())(quotesRaw).pipe(Effect.catchAll((error) => {
+		// eslint-disable-next-line no-console
+		console.error('Error decoding quote from storage:', error);
+		
+		return Effect.succeed(null);
+	}));
+	const data = yield* Schema.decodeUnknown(Schema.Array(quoteSchema))(quotesJSON);
+	
+	return data;
+});
+
+export const loadData = Effect.gen(function* () {
+	const state = yield* getState.pipe(Effect.catchAll((error) => Effect.gen(function* () {
+		yield* Effect.logError('Failed to get state', error);
+		
+		return null;
+	})));
+	
+	const { quoteTimestamp, currentTime } = yield* getTimeData;
+	
+	if(state === null) {
+		const version = yield* getVersionInfo;
+
+		const data = yield* getRemoteData(getLanguage(version));
+
+		const state = {
+			index: Math.floor(Math.random() * data.length),
+			date: quoteTimestamp,
+			language: getLanguage(version),
+			version: version.version,
+			lastUpdateCheck: currentTime,
+			deviceLanguage: getLocales()[0].languageTag.split('-')[0],
+		};
+
+		yield* saveQuotes(data);
+		yield* setState({ ...state, date: quoteTimestamp }).pipe(Effect.catchAll((error) => Effect.logError('Failed to set state', error)));
+			
+		return { state }; 
+	}
+	
+	if(yield* checkUpdata(state) || hasLanguageChanged(state)) {
+		const version = yield* getVersionInfo;
+
+		const data = yield* getRemoteData(getLanguage(version));
+		yield* saveQuotes(data);
+		yield* setState({ ...state, date: quoteTimestamp, version: version.version, language: getLanguage(version) }).pipe(Effect.catchAll((error) => Effect.logError('Failed to set state', error)));
+	}
+
+	if((hasLanguageChanged(state)) && (yield* renewState(state))) {
+		const version = yield* getVersionInfo;
+
+		const data = yield* getRemoteData(getLanguage(version));
+		yield* saveQuotes(data);
+		yield* setState({ ...state, date: quoteTimestamp, version: version.version, language: getLanguage(version) }).pipe(Effect.catchAll((error) => Effect.logError('Failed to set state', error)));
+	}
+
+	return { state };
+}).pipe(Effect.catchAll((error) => {	
+	return Effect.gen(function* () {
+		yield* Effect.logError('Failed to load data', error);
+		
+		return { state: null };
+	});
+}));

package/files/templates/expo verse[D]/files/lib/helper.ts

@@ -0,0 +1,54 @@
+import { DateTime, Effect } from 'effect';
+import { getLocales } from 'expo-localization';
+
+import { DataState, Version } from '@/models';
+
+import { FALLBACK_LOCALE } from '../constants/config';
+
+
+export const getTimeData = Effect.gen(function* () {
+	const currentTime = yield* DateTime.now;
+	const quoteTimestamp = DateTime.setParts(currentTime, { hours: 4, minutes: 30, seconds: 0 });
+	
+	return { quoteTimestamp, currentTime };
+});
+/**
+ * Get the language to use for the quote.
+ * @param version The version of the app.
+ * @returns The language to use for the quote.
+ */
+export function getLanguage(version: Version) {
+	const locale = getLocales()[0].languageTag.split('-')[0];
+	if(version.languages.includes(locale)) return locale.toLowerCase();
+	
+	return FALLBACK_LOCALE.toLowerCase();
+};
+
+/**
+ * Check if the language has changed.
+ * @param state The state of the app.
+ * @returns Whether the language has changed.
+ */
+export function hasLanguageChanged(state: DataState) {
+	const locale = getLocales()[0].languageTag.split('-')[0];
+	
+	return state.deviceLanguage.toLowerCase() !== locale.toLowerCase();
+}
+export const renewState = (state: DataState) => Effect.gen(function* () {
+	// if(__DEV__) return true;
+	
+	const { currentTime } = yield* getTimeData;
+	const elapsed = DateTime.distance(state.date, currentTime);
+	if (elapsed >= 86400000) return true;
+	
+	return false;
+});
+export const checkUpdata = (state: DataState) => Effect.gen(function* () {
+	// if(__DEV__) return true;
+
+	const { currentTime } = yield* getTimeData;
+	const elapsed = DateTime.distance(state.lastUpdateCheck, currentTime);
+	if (elapsed >= 86400000) return true;
+	
+	return false;
+});

package/files/templates/expo verse[D]/files/lib/index.ts

@@ -0,0 +1,21 @@
+import { Effect } from 'effect';
+
+import { STATE_KEY, STORAGE_KEY } from '../constants/config';
+import { getQuotes } from './data';
+import { getState, removeState } from './state';
+import { clearStorage } from './storage';
+
+
+export const clearData = Effect.gen(function* () {
+	yield* Effect.log('Clearing data');
+	yield* removeState;
+	yield* clearStorage(STORAGE_KEY);
+	yield* clearStorage(STATE_KEY);
+});
+
+export const showData = Effect.gen(function* () {
+	yield* Effect.log('Showing data');
+	const state = yield* getState;
+	const data = yield* getQuotes();
+	yield* Effect.log({ data, state });
+});

package/files/templates/expo verse[D]/files/lib/state.ts

@@ -0,0 +1,128 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Data, Effect, Schema } from 'effect';
+import { fetch } from 'expo/fetch';
+
+import { DataState, dataStateSchema, versionSchema } from '@/models';
+
+import { BASE_URL, CACHE_CONTROL, STATE_KEY, USER_AGENT } from '../constants/config';
+import { clearStorage } from './storage';
+
+export class StateError extends Data.TaggedError('StateError')<{reason: string, error: unknown}> {}
+export class GetVersionError extends Data.TaggedError('GetVersionError')<{reason: string, error: unknown}> {}
+
+export const getState = Effect.gen(function* () {
+	const rawState =yield* Effect.tryPromise({
+		try: () => AsyncStorage.getItem(STATE_KEY),
+		catch: (error) => {
+			return new StateError({ reason: 'Failed to save state to storage', error });
+		}
+	});
+	if(rawState === null) return null;
+
+	const stateJSON = yield* Schema.decodeUnknown(Schema.parseJson())(rawState).pipe(Effect.catchAll((error) => {
+		// eslint-disable-next-line no-console
+		console.error('Error decoding quote from storage:', error);
+		
+		return Effect.gen(function* () {
+			yield* clearStorage(STATE_KEY).pipe(Effect.catchAll((error) => {
+				// eslint-disable-next-line no-console
+				console.error('Error clearing storage:', error);
+				
+				return Effect.succeed(null);
+			}));
+			
+			return yield* Effect.succeed(null);
+		});
+	}));
+
+	const data = yield* Schema.decodeUnknown(dataStateSchema)(stateJSON).pipe(
+		Effect.catchAll((error) => {
+			// eslint-disable-next-line no-console
+			console.error('Failed to decode state from storage:', error);
+			
+			return Effect.gen(function* () {
+				yield* clearStorage(STATE_KEY).pipe(Effect.catchAll((error) => {
+					// eslint-disable-next-line no-console
+					console.error('Error clearing storage:', error);
+					
+					return Effect.succeed(null);
+				}));
+				
+				return yield* Effect.succeed(null);
+			});
+		}
+		)
+	);
+	
+	return data;
+});
+
+export const setState = (state: DataState) => {
+	return Effect.gen(function* () {
+		yield* Effect.tryPromise({
+			try: () => AsyncStorage.setItem(STATE_KEY, JSON.stringify(state)),
+			catch: (error) => {
+				// eslint-disable-next-line no-console
+				console.error('Error saving state to storage:', error);
+				
+				return new StateError({ reason: 'Failed to save state to storage', error });
+			}
+		});
+	});
+};
+
+export const removeState = Effect.gen(function* () {
+	yield* Effect.tryPromise({
+		try: () => AsyncStorage.removeItem(STATE_KEY),
+		catch: (error) => {
+			return new StateError({ reason: 'Failed to remove state to storage', error });
+		}
+	});
+});
+
+
+export const getVersionInfo = Effect.gen(function* () {
+	const response = yield* Effect.tryPromise({
+		try: () => fetch(BASE_URL.toString() + '/' + 'version.json', {
+			headers: {
+				'Cache-Control': CACHE_CONTROL,
+				'user-agent': USER_AGENT,
+			},
+		}),
+		catch: (error) => {
+			return new StateError({
+				reason: 'Failed to fetch state from remote',
+				error,
+			});
+		},
+	});
+
+	if (!response.ok) {		
+		return yield* Effect.fail(new StateError({
+			reason: `Failed to fetch version: ${response.status} ${response.statusText}`,
+			error: new Error(`Failed to fetch version: ${response.status} ${response.statusText}`),
+		}));
+	}
+	const jsonVersion = yield* Effect.tryPromise({
+		try: () => response.json(),
+		catch: (error) => {
+			return new GetVersionError({
+				reason: 'Failed to decode remote state from JSON',
+				error,
+			});
+		},
+	});
+
+	const version = yield* Schema.decodeUnknown(versionSchema)(jsonVersion, { onExcessProperty: 'ignore' }).pipe(
+		Effect.catchAll((error) => {
+			return Effect.fail(
+				new GetVersionError({
+					reason: 'Failed to decode state from remote state',
+					error,
+				}),
+			);
+		}),
+	);	
+	
+	return version;
+});